dacha 0.15.2 → 0.16.0

package/build/contrib/systems/animator/substate-pickers/index.d.ts

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

package/build/contrib/systems/animator/substate-pickers/one-dimensional-picker.d.ts

@@ -4,5 +4,5 @@ import type { OneDimensionalProps } from '../../../components/animatable/one-dim
 import type { Picker } from './picker';
 export declare class OneDimensionalPicker implements Picker {
     private getDistance;
-    getSubstate(actor: Actor, substates: Array<Substate>, props: OneDimensionalProps): Substate;
+    getSubstate(actor: Actor, substates: Substate[], props: OneDimensionalProps): Substate;
 }

package/build/contrib/systems/animator/substate-pickers/picker.d.ts

@@ -3,5 +3,5 @@ import type { Substate } from '../../../components/animatable/substate';
 import type { OneDimensionalProps } from '../../../components/animatable/one-dimensional-props';
 import type { TwoDimensionalProps } from '../../../components/animatable/two-dimensional-props';
 export interface Picker {
-    getSubstate(actor: Actor, substates: Array<Substate>, props: OneDimensionalProps | TwoDimensionalProps): Substate;
+    getSubstate(actor: Actor, substates: Substate[], props: OneDimensionalProps | TwoDimensionalProps): Substate;
 }

package/build/contrib/systems/animator/substate-pickers/two-dimensional-picker.d.ts

@@ -4,5 +4,5 @@ import type { TwoDimensionalProps } from '../../../components/animatable/two-dim
 import { Picker } from './picker';
 export declare class TwoDimensionalPicker implements Picker {
     private getDistance;
-    getSubstate(actor: Actor, substates: Array<Substate>, props: TwoDimensionalProps): Substate;
+    getSubstate(actor: Actor, substates: Substate[], props: TwoDimensionalProps): Substate;
 }

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

@@ -1,3 +1,3 @@
 import { Actor } from '../../../engine/actor';
-export declare const getValue: (actor: Actor, path: Array<string> | string) => unknown;
-export declare const setValue: (actor: Actor, path: Array<string>, value: unknown) => void;
+export declare const getValue: (actor: Actor, path: string[] | string) => unknown;
+export declare const setValue: (actor: Actor, path: string[], value: unknown) => void;

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

@@ -1,7 +1,6 @@
 import { Actor } from '../../../engine/actor';
 const PATH_COMPONENTS = 'components';
 const PATH_CHILDREN = 'children';
-// eslint-disable-next-line @typescript-eslint/naming-convention
 const _getValue = (actor, path, pathDepth) => {
     let soughtValue = actor;
     for (let i = 0; i < pathDepth && soughtValue !== undefined; i += 1) {

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

@@ -8,7 +8,7 @@ export declare class AudioSystem extends WorldSystem {
     private audioGroups;
     private audioStore;
     private audioState;
-    private actorCollection?;
+    private actorQuery?;
     constructor(options: WorldSystemOptions);
     onSceneLoad(scene: Scene): Promise<void>;
     onSceneEnter(scene: Scene): void;

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

@@ -1,9 +1,9 @@
 import { WorldSystem } from '../../../engine/system';
-import { Actor, ActorCollection } from '../../../engine/actor';
+import { Actor, ActorQuery } from '../../../engine/actor';
 import { AddActor, RemoveActor } from '../../../engine/events';
 import { CacheStore } from '../../../engine/data-lib';
 import { AudioSource } from '../../components';
-import { PlayAudio, StopAudio, SetAudioVolume, } from '../../../events';
+import { PlayAudio, StopAudio, SetAudioVolume } from '../../../events';
 import { getAllSources, loadAudio } from './utils';
 const MASTER_GROUP = 'master';
 const VOLUME_TOLERANCE = 0.001;
@@ -14,7 +14,7 @@ export class AudioSystem extends WorldSystem {
     audioGroups;
     audioStore;
     audioState;
-    actorCollection;
+    actorQuery;
     constructor(options) {
         super();
         const { world, globalOptions, templateCollection } = options;
@@ -42,7 +42,9 @@ export class AudioSystem extends WorldSystem {
         this.world.addEventListener(SetAudioVolume, this.handleSetAudioVolume);
         window.addEventListener('click', this.resumeIfSuspended, { once: true });
         window.addEventListener('keydown', this.resumeIfSuspended, { once: true });
-        window.addEventListener('touchstart', this.resumeIfSuspended, { once: true });
+        window.addEventListener('touchstart', this.resumeIfSuspended, {
+            once: true,
+        });
     }
     async onSceneLoad(scene) {
         const allSources = [
@@ -61,20 +63,21 @@ export class AudioSystem extends WorldSystem {
         allSources.forEach((src) => this.audioStore.retain(src));
     }
     onSceneEnter(scene) {
-        this.actorCollection = new ActorCollection(scene, {
-            components: [AudioSource],
+        this.actorQuery = new ActorQuery({
+            scene,
+            filter: [AudioSource],
         });
-        this.actorCollection.forEach((actor) => this.initAudio(actor));
-        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.getActors().forEach((actor) => this.initAudio(actor));
+        this.actorQuery.addEventListener(AddActor, this.handleActorAdd);
+        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
     }
     onSceneExit() {
         this.audioState.forEach((audioState) => {
             audioState.sourceNode.stop();
         });
-        this.actorCollection?.removeEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection?.removeEventListener(RemoveActor, this.handleActorRemove);
-        this.actorCollection = undefined;
+        this.actorQuery?.removeEventListener(AddActor, this.handleActorAdd);
+        this.actorQuery?.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery = undefined;
     }
     onSceneDestroy(scene) {
         const allSources = [
@@ -143,9 +146,7 @@ export class AudioSystem extends WorldSystem {
     };
     resumeIfSuspended = () => {
         if (this.audioContext.state === 'suspended') {
-            void this.audioContext
-                .resume()
-                .catch((err) => {
+            void this.audioContext.resume().catch((err) => {
                 console.warn('Cannot resume a audio context', err);
             });
         }
@@ -161,7 +162,7 @@ export class AudioSystem extends WorldSystem {
         if (!audioSource) {
             return;
         }
-        const { src, group, volume, looped, playing, } = audioSource;
+        const { src, group, volume, looped, playing } = audioSource;
         const audioGroupNode = this.audioGroups[group];
         if (!audioGroupNode || !this.audioStore.has(src)) {
             return;
@@ -206,12 +207,13 @@ export class AudioSystem extends WorldSystem {
     updateAudio(actor) {
         const audioSource = actor.getComponent(AudioSource);
         const audioState = this.audioState.get(actor.id);
-        if (Math.abs(audioSource.volume - audioState.properties.volume) > VOLUME_TOLERANCE) {
+        if (Math.abs(audioSource.volume - audioState.properties.volume) >
+            VOLUME_TOLERANCE) {
             audioState.gainNode.gain.value = audioSource.volume;
         }
     }
     update() {
-        this.actorCollection?.forEach((actor) => {
+        this.actorQuery?.getActors().forEach((actor) => {
             const audioSource = actor.getComponent(AudioSource);
             const audioState = this.audioState.get(actor.id);
             if (audioSource.playing && audioState) {

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

@@ -1,4 +1,4 @@
-export type AudioStateNode = {
+export interface AudioStateNode {
     sourceNode: AudioBufferSourceNode;
     gainNode: GainNode;
     properties: {
@@ -6,12 +6,12 @@ export type AudioStateNode = {
         group: string;
         endedListener: () => void;
     };
-};
-export type AudioGroup = {
+}
+export interface AudioGroup {
     id: string;
     name: string;
     volume: number;
-};
-export type AudioGroups = {
+}
+export interface AudioGroups {
     groups: AudioGroup[];
-};
+}

package/build/contrib/systems/behavior-system/system.d.ts

@@ -9,7 +9,9 @@ export declare class BehaviorSystem extends SceneSystem {
     private scene;
     private activeBehaviors;
     constructor(options: SceneSystemOptions);
+    onSceneEnter(): void;
     onSceneDestroy(): void;
+    private handleActorAdd;
     private handleActorRemove;
     private setUpBehavior;
     update(options: UpdateOptions): void;

package/build/contrib/systems/behavior-system/system.js

@@ -1,7 +1,7 @@
 import { SceneSystem } from '../../../engine/system';
 import { ActorCollection } from '../../../engine/actor';
 import { Behaviors } from '../../components';
-import { RemoveActor } from '../../../engine/events';
+import { AddActor, RemoveActor } from '../../../engine/events';
 export class BehaviorSystem extends SceneSystem {
     behaviorCollection;
     actorSpawner;
@@ -28,15 +28,24 @@ export class BehaviorSystem extends SceneSystem {
             return acc;
         }, {});
         this.activeBehaviors = {};
+    }
+    onSceneEnter() {
+        this.behaviorCollection.forEach((actor) => this.setUpBehavior(actor));
+        this.behaviorCollection.addEventListener(AddActor, this.handleActorAdd);
         this.behaviorCollection.addEventListener(RemoveActor, this.handleActorRemove);
     }
     onSceneDestroy() {
+        this.behaviorCollection.removeEventListener(AddActor, this.handleActorAdd);
         this.behaviorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
         this.behaviorCollection.forEach((actor) => {
             this.activeBehaviors[actor.id].forEach((behavior) => behavior.destroy?.());
             delete this.activeBehaviors[actor.id];
         });
     }
+    handleActorAdd = (event) => {
+        const { actor } = event;
+        this.setUpBehavior(actor);
+    };
     handleActorRemove = (event) => {
         const { actor } = event;
         this.activeBehaviors[actor.id].forEach((behavior) => behavior.destroy?.());
@@ -44,7 +53,14 @@ export class BehaviorSystem extends SceneSystem {
     };
     setUpBehavior(actor) {
         const { list } = actor.getComponent(Behaviors);
-        this.activeBehaviors[actor.id] = list.map((config) => {
+        this.activeBehaviors[actor.id] = list
+            .filter((config) => {
+            if (!this.behaviors[config.name]) {
+                console.warn(`Behavior not found: ${config.name}`);
+            }
+            return this.behaviors[config.name];
+        })
+            .map((config) => {
             const options = {
                 ...config.options,
                 actor,
@@ -59,9 +75,6 @@ export class BehaviorSystem extends SceneSystem {
     }
     update(options) {
         this.behaviorCollection.forEach((actor) => {
-            if (!this.activeBehaviors[actor.id]) {
-                this.setUpBehavior(actor);
-            }
             this.activeBehaviors[actor.id].forEach((behavior) => behavior.update?.(options));
         });
     }

package/build/contrib/systems/camera-system/system.d.ts

@@ -2,7 +2,7 @@ import { WorldSystem } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 import type { WorldSystemOptions } from '../../../engine/system';
 export declare class CameraSystem extends WorldSystem {
-    private actorCollection?;
+    private actorQuery?;
     private window;
     private cameraService;
     constructor(options: WorldSystemOptions);

package/build/contrib/systems/camera-system/system.js

@@ -1,15 +1,15 @@
 import { WorldSystem } from '../../../engine/system';
-import { ActorCollection } from '../../../engine/actor';
+import { ActorQuery } from '../../../engine/actor';
 import { Camera } from '../../components/camera';
 import { getWindowNode } from '../../utils/get-window-node';
 import { CameraService } from './service';
 export class CameraSystem extends WorldSystem {
-    actorCollection;
+    actorQuery;
     window;
     cameraService;
     constructor(options) {
         super();
-        const { windowNodeId, world, } = options;
+        const { windowNodeId, world } = options;
         const windowNode = getWindowNode(windowNodeId);
         this.window = windowNode;
         this.cameraService = new CameraService({
@@ -20,13 +20,14 @@ export class CameraSystem extends WorldSystem {
         window.addEventListener('resize', this.handleWindowResize);
     }
     onSceneEnter(scene) {
-        this.actorCollection = new ActorCollection(scene, {
-            components: [Camera],
+        this.actorQuery = new ActorQuery({
+            scene,
+            filter: [Camera],
         });
         this.handleWindowResize();
     }
     onSceneExit() {
-        this.actorCollection = undefined;
+        this.actorQuery = undefined;
     }
     onWorldDestroy() {
         window.removeEventListener('resize', this.handleWindowResize);
@@ -46,17 +47,22 @@ export class CameraSystem extends WorldSystem {
         }
     };
     handleCameraUpdate = (actor) => {
-        this.actorCollection?.forEach((cameraActor) => {
+        this.actorQuery?.getActors().forEach((cameraActor) => {
             const camera = cameraActor.getComponent(Camera);
             camera.current = actor.id === cameraActor.id;
         });
         this.handleWindowResize();
     };
     findCurrentCamera = () => {
-        return this.actorCollection?.find((actor) => {
+        if (!this.actorQuery) {
+            return;
+        }
+        for (const actor of this.actorQuery.getActors()) {
             const camera = actor.getComponent(Camera);
-            return camera.current;
-        });
+            if (camera.current) {
+                return actor;
+            }
+        }
     };
 }
 CameraSystem.systemName = 'CameraSystem';

package/build/contrib/systems/game-stats-meter/index.d.ts

@@ -3,7 +3,7 @@ import type { WorldSystemOptions, UpdateOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 export declare class GameStatsMeter extends WorldSystem {
     private world;
-    private actorCollection?;
+    private actorQuery?;
     private frequency;
     private fps;
     private time;

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

@@ -1,26 +1,26 @@
 import { WorldSystem } from '../../../engine/system';
 import { GameStatsUpdate } from '../../events';
-import { ActorCollection } from '../../../engine/actor';
+import { ActorQuery } from '../../../engine/actor';
 const MS_IN_SEC = 1000;
 export class GameStatsMeter extends WorldSystem {
     world;
-    actorCollection;
+    actorQuery;
     frequency;
     fps;
     time;
     constructor(options) {
         super();
-        const { world, frequency, } = options;
+        const { world, frequency } = options;
         this.world = world;
         this.frequency = frequency || MS_IN_SEC;
         this.fps = 0;
         this.time = 0;
     }
     onSceneEnter(scene) {
-        this.actorCollection = new ActorCollection(scene);
+        this.actorQuery = new ActorQuery({ scene, filter: [] });
     }
     onSceneExit() {
-        this.actorCollection = undefined;
+        this.actorQuery = undefined;
     }
     update(options) {
         const { deltaTime } = options;
@@ -29,7 +29,7 @@ export class GameStatsMeter extends WorldSystem {
         if (this.time >= this.frequency) {
             this.world.dispatchEvent(GameStatsUpdate, {
                 fps: (this.fps * MS_IN_SEC) / this.time,
-                actorsCount: this.actorCollection?.size ?? 0,
+                actorsCount: this.actorQuery?.getActors().size ?? 0,
             });
             this.fps = 0;
             this.time = 0;

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

@@ -8,7 +8,7 @@ export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export type { BehaviorOptions } from './behavior-system';
-export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
 export { UIBridge } from './ui-bridge';
-export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn, } from './ui-bridge';
+export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
 export { AudioSystem } from './audio-system';
+export { Renderer, RendererService } from './renderer';

package/build/contrib/systems/index.js

@@ -7,6 +7,6 @@ export { MouseControlSystem } from './mouse-control-system';
 export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
-export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
 export { UIBridge } from './ui-bridge';
 export { AudioSystem } from './audio-system';
+export { Renderer, RendererService } from './renderer';

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

@@ -3,7 +3,7 @@ import type { WorldSystemOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 export declare class KeyboardControlSystem extends WorldSystem {
     private world;
-    private actorCollection?;
+    private actorQuery?;
     private pressedKeys;
     private events;
     constructor(options: WorldSystemOptions);

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

@@ -1,10 +1,10 @@
 import { WorldSystem } from '../../../engine/system';
-import { ActorCollection } from '../../../engine/actor';
+import { ActorQuery } from '../../../engine/actor';
 import { KeyboardControl } from '../../components/keyboard-control';
 import { KeyboardInput } from '../../events';
 export class KeyboardControlSystem extends WorldSystem {
     world;
-    actorCollection;
+    actorQuery;
     pressedKeys;
     events;
     constructor(options) {
@@ -15,12 +15,10 @@ export class KeyboardControlSystem extends WorldSystem {
         this.world.addEventListener(KeyboardInput, this.handleKeyboardInput);
     }
     onSceneEnter(scene) {
-        this.actorCollection = new ActorCollection(scene, {
-            components: [KeyboardControl],
-        });
+        this.actorQuery = new ActorQuery({ scene, filter: [KeyboardControl] });
     }
     onSceneExit() {
-        this.actorCollection = undefined;
+        this.actorQuery = undefined;
     }
     onWorldDestroy() {
         this.world.removeEventListener(KeyboardInput, this.handleKeyboardInput);
@@ -42,7 +40,7 @@ export class KeyboardControlSystem extends WorldSystem {
                 this.pressedKeys.delete(event.key);
             }
         });
-        this.actorCollection?.forEach((actor) => {
+        this.actorQuery?.getActors().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) => {

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

@@ -7,6 +7,6 @@ export declare class InputListener {
     handleKeyUp: (event: Event) => void;
     startListen(): void;
     stopListen(): void;
-    getEvents(): Array<CustomKeyboardEvent>;
+    getEvents(): CustomKeyboardEvent[];
     clear(): void;
 }

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

@@ -2,7 +2,7 @@ import { WorldSystem } from '../../../engine/system';
 import type { WorldSystemOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 export declare class MouseControlSystem extends WorldSystem {
-    private actorCollection?;
+    private actorQuery?;
     private world;
     constructor(options: WorldSystemOptions);
     onSceneEnter(scene: Scene): void;

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

@@ -1,9 +1,9 @@
 import { WorldSystem } from '../../../engine/system';
-import { ActorCollection } from '../../../engine/actor';
+import { ActorQuery } from '../../../engine/actor';
 import { MouseControl } from '../../components/mouse-control';
 import { MouseInput } from '../../events';
 export class MouseControlSystem extends WorldSystem {
-    actorCollection;
+    actorQuery;
     world;
     constructor(options) {
         super();
@@ -11,18 +11,16 @@ export class MouseControlSystem extends WorldSystem {
         this.world.addEventListener(MouseInput, this.handleMouseInput);
     }
     onSceneEnter(scene) {
-        this.actorCollection = new ActorCollection(scene, {
-            components: [MouseControl],
-        });
+        this.actorQuery = new ActorQuery({ scene, filter: [MouseControl] });
     }
     onSceneExit() {
-        this.actorCollection = undefined;
+        this.actorQuery = undefined;
     }
     onWorldDestroy() {
         this.world.removeEventListener(MouseInput, this.handleMouseInput);
     }
     handleMouseInput = (event) => {
-        this.actorCollection?.forEach((actor) => {
+        this.actorQuery?.getActors().forEach((actor) => {
             const control = actor.getComponent(MouseControl);
             const eventBinding = control.inputEventBindings[event.eventType]?.[event.button];
             if (eventBinding) {

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

@@ -6,6 +6,6 @@ export declare class MouseInputListener {
     handleMouseEvent: (event: Event) => void;
     startListen(): void;
     stopListen(): void;
-    getFiredEvents(): Array<CustomMouseEvent>;
+    getFiredEvents(): CustomMouseEvent[];
     clearFiredEvents(): void;
 }

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

@@ -1,6 +1,6 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
 export declare class CollisionDetectionSubsystem {
-    private actorCollection;
+    private actorQuery;
     private scene;
     private axis;
     private entriesMap;

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

@@ -1,5 +1,5 @@
-import { ActorCollection } from '../../../../../engine/actor';
-import { Transform, Collider, RigidBody, } from '../../../../components';
+import { ActorQuery } from '../../../../../engine/actor';
+import { Transform, Collider, RigidBody } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
 import { Collision } from '../../../../events';
 import { insertionSort } from '../../../../../engine/data-lib';
@@ -9,18 +9,16 @@ import { intersectionCheckers } from './intersection-checkers';
 import { DispersionCalculator } from './dispersion-calculator';
 import { checkTransform, checkCollider } from './reorientation-checkers';
 export class CollisionDetectionSubsystem {
-    actorCollection;
+    actorQuery;
     scene;
     axis;
     entriesMap;
     collisionPairs;
     entriesToDelete;
     constructor(options) {
-        this.actorCollection = new ActorCollection(options.scene, {
-            components: [
-                Collider,
-                Transform,
-            ],
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [Collider, Transform],
         });
         this.scene = options.scene;
         this.axis = {
@@ -36,13 +34,15 @@ export class CollisionDetectionSubsystem {
         this.entriesMap = new Map();
         this.collisionPairs = [];
         this.entriesToDelete = new Set();
-        this.actorCollection.forEach((actor) => this.addCollisionEntry(actor));
-        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery
+            .getActors()
+            .forEach((actor) => this.addCollisionEntry(actor));
+        this.actorQuery.addEventListener(AddActor, this.handleActorAdd);
+        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
     }
     destroy() {
-        this.actorCollection.removeEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.removeEventListener(AddActor, this.handleActorAdd);
+        this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
     }
     handleActorAdd = (event) => {
         this.addCollisionEntry(event.actor);
@@ -59,7 +59,8 @@ export class CollisionDetectionSubsystem {
         const collider = actor.getComponent(Collider);
         const transformOld = entry.orientationData.transform;
         const colliderOld = entry.orientationData.collider;
-        return checkTransform(transform, transformOld) || checkCollider(collider, colliderOld);
+        return (checkTransform(transform, transformOld) ||
+            checkCollider(collider, colliderOld));
     }
     getOrientationData(actor) {
         const transform = actor.getComponent(Transform);
@@ -148,7 +149,7 @@ export class CollisionDetectionSubsystem {
     testAABB(entry1, entry2, axis) {
         const aabb1 = entry1.aabb;
         const aabb2 = entry2.aabb;
-        return aabb1.max[axis] > aabb2.min[axis] && aabb1.min[axis] < aabb2.max[axis];
+        return (aabb1.max[axis] > aabb2.min[axis] && aabb1.min[axis] < aabb2.max[axis]);
     }
     sweepAndPrune() {
         const [mainAxis, secondAxis] = this.getAxes();
@@ -216,7 +217,7 @@ export class CollisionDetectionSubsystem {
     }
     update() {
         this.clearDeletedEntries();
-        this.actorCollection.forEach((actor) => {
+        this.actorQuery.getActors().forEach((actor) => {
             if (!this.checkOnReorientation(actor)) {
                 return;
             }

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

@@ -16,15 +16,15 @@ export interface Edge {
 export interface EdgeWithNormal extends Edge {
     normal: Vector2;
 }
-export type BoxGeometry = {
+export interface BoxGeometry {
     center: Point;
-    points: Array<Point>;
-    edges: Array<EdgeWithNormal>;
-};
-export type CircleGeometry = {
+    points: Point[];
+    edges: EdgeWithNormal[];
+}
+export interface CircleGeometry {
     center: Point;
     radius: number;
-};
+}
 export type Geometry = BoxGeometry | CircleGeometry;
 export interface OrientationData {
     transform: {
@@ -55,7 +55,7 @@ export interface SortedItem {
     value: number;
 }
 export interface AxisEntry {
-    sortedList: Array<SortedItem>;
+    sortedList: SortedItem[];
     dispersionCalculator: DispersionCalculator;
 }
 export type Axis = 'x' | 'y';
@@ -64,7 +64,7 @@ export interface Axes {
     y: AxisEntry;
 }
 export type CollisionPair = [CollisionEntry, CollisionEntry];
-export type Intersection = {
+export interface Intersection {
     mtv1: Vector2;
     mtv2: Vector2;
-};
+}

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

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

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

@@ -1,6 +1,5 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
 export declare class ConstraintSolver {
-    private actorCollection;
     private scene;
     private processedPairs;
     private mtvMap;