dacha 0.14.4 → 0.15.0

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

@@ -0,0 +1,14 @@
+import { Component } from '../../../engine/component';
+interface BehaviorConfig {
+    name: string;
+    options: Record<string, unknown>;
+}
+export interface BehaviorsConfig {
+    list: BehaviorConfig[];
+}
+export declare class Behaviors extends Component {
+    list: BehaviorConfig[];
+    constructor(config: BehaviorsConfig);
+    clone(): Behaviors;
+}
+export {};

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

@@ -0,0 +1,15 @@
+import { Component } from '../../../engine/component';
+export class Behaviors extends Component {
+    list;
+    constructor(config) {
+        super();
+        const { list } = config;
+        this.list = list;
+    }
+    clone() {
+        return new Behaviors({
+            list: this.list.map(({ name, options }) => ({ name, options: { ...options } })),
+        });
+    }
+}
+Behaviors.componentName = 'Behaviors';

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

@@ -14,8 +14,8 @@ export { Transform } from './transform';
 export type { TransformConfig } from './transform';
 export { MouseControl } from './mouse-control';
 export type { MouseControlConfig } from './mouse-control';
-export { ScriptBundle } from './script-bundle';
-export type { ScriptBundleConfig } from './script-bundle';
+export { Behaviors } from './behaviors';
+export type { BehaviorsConfig } from './behaviors';
 export { Light } from './light';
 export type { LightConfig } from './light';
 export { AudioSource } from './audio-source';

package/build/contrib/components/index.js

@@ -6,6 +6,6 @@ export { Animatable } from './animatable';
 export { Sprite } from './sprite';
 export { Transform } from './transform';
 export { MouseControl } from './mouse-control';
-export { ScriptBundle } from './script-bundle';
+export { Behaviors } from './behaviors';
 export { Light } from './light';
 export { AudioSource } from './audio-source';

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

@@ -1,8 +1,7 @@
 import type { Actor } from '../../engine/actor';
 import type { Vector2 } from '../../engine/math-lib';
 import type { CustomMouseEvent, CustomKeyboardEvent } from '../types/input-events';
-import type { ActorEvent, SceneEvent } from '../../types/events';
-export declare const SetCamera = "SetCamera";
+import type { ActorEvent, SceneEvent, WorldEvent } from '../../types/events';
 export declare const GameStatsUpdate = "GameStatsUpdate";
 export declare const Collision = "Collision";
 export declare const KeyboardInput = "KeyboardInput";
@@ -16,25 +15,22 @@ export declare const StopMovement = "StopMovement";
 export declare const PlayAudio = "PlayAudio";
 export declare const StopAudio = "StopAudio";
 export declare const SetAudioVolume = "SetAudioVolume";
-export type MouseInputEvent = SceneEvent<CustomMouseEvent>;
-export type KeyboardInputEvent = SceneEvent<CustomKeyboardEvent>;
-export type SetCameraEvent = SceneEvent<{
-    actorId: string;
-}>;
-export type GameStatsUpdateEvent = SceneEvent<{
+export type MouseInputEvent = WorldEvent<CustomMouseEvent>;
+export type KeyboardInputEvent = WorldEvent<CustomKeyboardEvent>;
+export type GameStatsUpdateEvent = WorldEvent<{
     fps: number;
     actorsCount: number;
 }>;
+export type SetAudioGroupVolumeEvent = WorldEvent<{
+    group: string;
+    value: number;
+}>;
 export type CollisionEvent = SceneEvent<{
     actor1: Actor;
     actor2: Actor;
     mtv1: Vector2;
     mtv2: Vector2;
 }>;
-export type SetAudioGroupVolumeEvent = SceneEvent<{
-    group: string;
-    value: number;
-}>;
 export type MouseControlEvent<T = Record<string, never>> = ActorEvent<Pick<CustomMouseEvent, 'x' | 'y' | 'screenX' | 'screenY' | 'nativeEvent'>> & T;
 export type KeyboardControlEvent<T = Record<string, never>> = ActorEvent<T>;
 type CollisionStateEvent = ActorEvent<{
@@ -54,14 +50,15 @@ export type SetAudioSourceVolumeEvent = ActorEvent<{
     value: number;
 }>;
 declare module '../../types/events' {
-    interface SceneEventMap {
+    interface WorldEventMap {
         [MouseInput]: MouseInputEvent;
         [KeyboardInput]: KeyboardInputEvent;
-        [SetCamera]: SetCameraEvent;
         [GameStatsUpdate]: GameStatsUpdateEvent;
-        [Collision]: CollisionEvent;
         [SetAudioVolume]: SetAudioGroupVolumeEvent;
     }
+    interface SceneEventMap {
+        [Collision]: CollisionEvent;
+    }
     interface ActorEventMap {
         [CollisionEnter]: CollisionEnterEvent;
         [CollisionStay]: CollisionStayEvent;

package/build/contrib/events/index.js

@@ -1,4 +1,3 @@
-export const SetCamera = 'SetCamera';
 export const GameStatsUpdate = 'GameStatsUpdate';
 export const Collision = 'Collision';
 export const KeyboardInput = 'KeyboardInput';

package/build/contrib/systems/animator/condition-controllers/condition-controller.d.ts

@@ -1,3 +1,4 @@
 export interface ConditionController {
+    destroy?(): void;
     check(): boolean;
 }

package/build/contrib/systems/animator/condition-controllers/event-condition-controller.d.ts

@@ -2,7 +2,11 @@ import type { Actor } from '../../../../engine/actor';
 import type { EventConditionProps } from '../../../components/animatable/event-condition-props';
 import { ConditionController } from './condition-controller';
 export declare class EventConditionController implements ConditionController {
+    private actor;
+    private eventType;
     private isEventFired;
     constructor(props: EventConditionProps, actor: Actor);
+    destroy(): void;
+    private handleEvent;
     check(): boolean;
 }

package/build/contrib/systems/animator/condition-controllers/event-condition-controller.js

@@ -1,17 +1,23 @@
 export class EventConditionController {
+    actor;
+    eventType;
     isEventFired;
     constructor(props, actor) {
+        this.actor = actor;
+        this.eventType = props.eventType;
         this.isEventFired = false;
-        const { eventType } = props;
-        const handleEvent = (event) => {
-            if (event.target !== actor) {
-                return;
-            }
-            this.isEventFired = true;
-            actor.removeEventListener(eventType, handleEvent);
-        };
-        actor.addEventListener(eventType, handleEvent);
+        this.actor.addEventListener(this.eventType, this.handleEvent);
     }
+    destroy() {
+        this.actor.removeEventListener(this.eventType, this.handleEvent);
+    }
+    handleEvent = (event) => {
+        if (event.target !== this.actor) {
+            return;
+        }
+        this.isEventFired = true;
+        this.actor.removeEventListener(this.eventType, this.handleEvent);
+    };
     check() {
         return this.isEventFired;
     }

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

@@ -1,12 +1,11 @@
-import { System } from '../../../engine/system';
-import type { SystemOptions, UpdateOptions } from '../../../engine/system';
-export declare class Animator extends System {
+import { SceneSystem } from '../../../engine/system';
+import type { UpdateOptions, SceneSystemOptions } from '../../../engine/system';
+export declare class Animator extends SceneSystem {
     private actorCollection;
     private substatePickers;
     private actorConditions;
-    constructor(options: SystemOptions);
-    mount(): void;
-    unmount(): void;
+    constructor(options: SceneSystemOptions);
+    onSceneDestroy(): void;
     private handleActorRemove;
     private setUpConditionControllers;
     private updateFrame;

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

@@ -1,4 +1,4 @@
-import { System } from '../../../engine/system';
+import { SceneSystem } from '../../../engine/system';
 import { ActorCollection } from '../../../engine/actor';
 import { Animatable } from '../../components/animatable';
 import { RemoveActor } from '../../../engine/events';
@@ -6,7 +6,7 @@ import { conditionControllers } from './condition-controllers';
 import { substatePickers } from './substate-pickers';
 import { setValue } from './utils';
 const FRAME_RATE = 100;
-export class Animator extends System {
+export class Animator extends SceneSystem {
     actorCollection;
     substatePickers;
     actorConditions;
@@ -22,12 +22,17 @@ export class Animator extends System {
             return storage;
         }, {});
         this.actorConditions = {};
-    }
-    mount() {
         this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
     }
-    unmount() {
+    onSceneDestroy() {
         this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        Object.values(this.actorConditions).forEach((transitions) => {
+            Object.values(transitions).forEach((conditions) => {
+                Object.values(conditions).forEach((controller) => {
+                    controller.destroy?.();
+                });
+            });
+        });
     }
     handleActorRemove = (event) => {
         delete this.actorConditions[event.actor.id];

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

@@ -1,18 +1,22 @@
-import { System } from '../../../engine/system';
-import type { SystemOptions } from '../../../engine/system';
-export declare class AudioSystem extends System {
+import { WorldSystem } from '../../../engine/system';
+import type { Scene } from '../../../engine/scene';
+import type { WorldSystemOptions } from '../../../engine/system';
+export declare class AudioSystem extends WorldSystem {
     private templateCollection;
-    private actorCollection;
-    private scene;
+    private world;
+    private scene?;
     private audioContext;
     private audioGroups;
-    private audioCache;
+    private audioStore;
     private audioState;
-    constructor(options: SystemOptions);
-    load(): Promise<void>;
+    private actorCollections;
+    constructor(options: WorldSystemOptions);
+    onSceneLoad(scene: Scene): Promise<void>;
+    onSceneEnter(scene: Scene): void;
+    onSceneExit(scene: Scene): void;
+    onSceneDestroy(scene: Scene): void;
+    onWorldDestroy(): void;
     private loadAudio;
-    mount(): void;
-    unmount(): void;
     private handleActorAdd;
     private handleActorRemove;
     private handlePlayAudio;

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

@@ -1,27 +1,26 @@
-import { System } from '../../../engine/system';
+import { WorldSystem } from '../../../engine/system';
 import { Actor, ActorCollection } 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 { audioLoader } from './audio-loader';
+import { getAllTemplateSources, loadAudio } from './utils';
 const MASTER_GROUP = 'master';
 const VOLUME_TOLERANCE = 0.001;
-export class AudioSystem extends System {
+export class AudioSystem extends WorldSystem {
     templateCollection;
-    actorCollection;
+    world;
     scene;
     audioContext;
     audioGroups;
-    audioCache;
+    audioStore;
     audioState;
+    actorCollections;
     constructor(options) {
         super();
-        const { scene, globalOptions, templateCollection } = options;
+        const { world, globalOptions, templateCollection } = options;
         this.templateCollection = templateCollection;
-        this.actorCollection = new ActorCollection(scene, {
-            components: [AudioSource],
-        });
-        this.scene = scene;
+        this.world = world;
         this.audioContext = new AudioContext();
         const masterAudioGroup = new GainNode(this.audioContext);
         masterAudioGroup.connect(this.audioContext.destination);
@@ -37,60 +36,92 @@ export class AudioSystem extends System {
             acc[groupSettings.name] = gainNode;
             return acc;
         }, { [MASTER_GROUP]: masterAudioGroup });
-        this.audioCache = new Map();
+        this.audioStore = new CacheStore();
         this.audioState = new Map();
-    }
-    async load() {
-        const templateSources = this.templateCollection.getAll()
-            .filter((template) => template.getComponent(AudioSource))
-            .map((template) => template.getComponent(AudioSource).src);
-        const sources = this.actorCollection.map((actor) => actor.getComponent(AudioSource).src);
-        const uniqueSources = [...new Set([...templateSources, ...sources])];
-        await Promise.all(uniqueSources.map((src) => this.loadAudio(src)));
-    }
-    async loadAudio(audioSourcePath) {
-        if (this.audioCache.has(audioSourcePath)) {
-            return;
-        }
-        try {
-            const arrayBuffer = await audioLoader.load(audioSourcePath);
-            const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
-            this.audioCache.set(audioSourcePath, audioBuffer);
-        }
-        catch (error) {
-            console.error(`An error occurred during audio source loading: ${audioSourcePath}`, error);
-        }
-    }
-    mount() {
-        this.actorCollection.forEach((actor) => this.initAudio(actor));
-        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.addEventListener(PlayAudio, this.handlePlayAudio);
-        this.scene.addEventListener(StopAudio, this.handleStopAudio);
-        this.scene.addEventListener(SetAudioVolume, this.handleSetAudioVolume);
+        this.actorCollections = {};
+        this.world.addEventListener(PlayAudio, this.handlePlayAudio);
+        this.world.addEventListener(StopAudio, this.handleStopAudio);
+        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 });
     }
-    unmount() {
+    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),
+        ];
+        const uniqueSources = [...new Set(allSources)];
+        const audioBuffers = await Promise.all(uniqueSources.map((src) => {
+            return !this.audioStore.has(src) ? this.loadAudio(src) : undefined;
+        }));
+        uniqueSources.forEach((src, index) => {
+            if (audioBuffers[index]) {
+                this.audioStore.add(src, audioBuffers[index]);
+            }
+        });
+        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);
+    }
+    onSceneExit(scene) {
         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;
+    }
+    onSceneDestroy(scene) {
+        const allSources = [
+            ...getAllTemplateSources(this.templateCollection),
+            ...this.actorCollections[scene.id].map((actor) => actor.getComponent(AudioSource).src),
+        ];
+        allSources.forEach((src) => this.audioStore.release(src));
+        this.audioStore.cleanReleased();
+        delete this.actorCollections[scene.id];
+    }
+    onWorldDestroy() {
         void this.audioContext.close();
-        this.actorCollection.removeEventListener(AddActor, this.handleActorAdd);
-        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
-        this.scene.removeEventListener(PlayAudio, this.handlePlayAudio);
-        this.scene.removeEventListener(StopAudio, this.handleStopAudio);
-        this.scene.removeEventListener(SetAudioVolume, this.handleSetAudioVolume);
+        this.world.removeEventListener(PlayAudio, this.handlePlayAudio);
+        this.world.removeEventListener(StopAudio, this.handleStopAudio);
+        this.world.removeEventListener(SetAudioVolume, this.handleSetAudioVolume);
         window.removeEventListener('click', this.resumeIfSuspended);
         window.removeEventListener('keydown', this.resumeIfSuspended);
         window.removeEventListener('touchstart', this.resumeIfSuspended);
     }
+    async loadAudio(src) {
+        if (!src) {
+            return undefined;
+        }
+        try {
+            const arrayBuffer = await loadAudio(src);
+            const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
+            return audioBuffer;
+        }
+        catch (error) {
+            console.error(`An error occurred during audio source loading: ${src}`, error);
+            return undefined;
+        }
+    }
     handleActorAdd = (event) => {
-        this.initAudio(event.actor);
+        const { actor } = event;
+        const { src } = actor.getComponent(AudioSource);
+        this.audioStore.retain(src);
+        this.initAudio(actor);
     };
     handleActorRemove = (event) => {
-        this.stopAudio(event.actor);
+        const { actor } = event;
+        const { src } = actor.getComponent(AudioSource);
+        this.audioStore.release(src);
+        this.stopAudio(actor);
     };
     handlePlayAudio = (event) => {
         this.playAudio(event.target);
@@ -136,7 +167,7 @@ export class AudioSystem extends System {
         }
         const { src, group, volume, looped, playing, } = audioSource;
         const audioGroupNode = this.audioGroups[group];
-        if (!audioGroupNode || !this.audioCache.has(src)) {
+        if (!audioGroupNode || !this.audioStore.has(src)) {
             return;
         }
         if (playing && this.audioState.has(actor.id)) {
@@ -146,7 +177,7 @@ export class AudioSystem extends System {
             prevAudio.gainNode.disconnect();
         }
         const sourceNode = new AudioBufferSourceNode(this.audioContext, {
-            buffer: this.audioCache.get(src),
+            buffer: this.audioStore.get(src),
             loop: looped,
         });
         const gainNode = new GainNode(this.audioContext, {
@@ -184,7 +215,10 @@ export class AudioSystem extends System {
         }
     }
     update() {
-        this.actorCollection.forEach((actor) => {
+        if (!this.scene) {
+            return;
+        }
+        this.actorCollections[this.scene.id]?.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

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

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

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

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

@@ -0,0 +1,3 @@
+export { BehaviorSystem } from './system';
+export { Behavior } from './types';
+export type { BehaviorOptions, BehaviorConstructor } from './types';

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

@@ -0,0 +1,2 @@
+export { BehaviorSystem } from './system';
+export { Behavior } from './types';

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

@@ -0,0 +1,16 @@
+import { SceneSystem } from '../../../engine/system';
+import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+export declare class BehaviorSystem extends SceneSystem {
+    private behaviorCollection;
+    private actorSpawner;
+    private globalOptions;
+    private behaviors;
+    private world;
+    private scene;
+    private activeBehaviors;
+    constructor(options: SceneSystemOptions);
+    onSceneDestroy(): void;
+    private handleActorRemove;
+    private setUpBehavior;
+    update(options: UpdateOptions): void;
+}

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

@@ -0,0 +1,69 @@
+import { SceneSystem } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { Behaviors } from '../../components';
+import { RemoveActor } from '../../../engine/events';
+export class BehaviorSystem extends SceneSystem {
+    behaviorCollection;
+    actorSpawner;
+    globalOptions;
+    behaviors;
+    world;
+    scene;
+    activeBehaviors;
+    constructor(options) {
+        super();
+        const { actorSpawner, world, scene, globalOptions, resources = {}, } = options;
+        this.world = world;
+        this.scene = scene;
+        this.behaviorCollection = new ActorCollection(scene, {
+            components: [Behaviors],
+        });
+        this.actorSpawner = actorSpawner;
+        this.globalOptions = globalOptions;
+        this.behaviors = resources.reduce((acc, behavior) => {
+            if (behavior.behaviorName === undefined) {
+                throw new Error(`Missing behaviorName field for ${behavior.name} behavior.`);
+            }
+            acc[behavior.behaviorName] = behavior;
+            return acc;
+        }, {});
+        this.activeBehaviors = {};
+        this.behaviorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+    }
+    onSceneDestroy() {
+        this.behaviorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.behaviorCollection.forEach((actor) => {
+            this.activeBehaviors[actor.id].forEach((behavior) => behavior.destroy?.());
+            delete this.activeBehaviors[actor.id];
+        });
+    }
+    handleActorRemove = (event) => {
+        const { actor } = event;
+        this.activeBehaviors[actor.id].forEach((behavior) => behavior.destroy?.());
+        delete this.activeBehaviors[actor.id];
+    };
+    setUpBehavior(actor) {
+        const { list } = actor.getComponent(Behaviors);
+        this.activeBehaviors[actor.id] = list.map((config) => {
+            const options = {
+                ...config.options,
+                actor,
+                actorSpawner: this.actorSpawner,
+                world: this.world,
+                scene: this.scene,
+                globalOptions: this.globalOptions,
+            };
+            const BehaviorClass = this.behaviors[config.name];
+            return new BehaviorClass(options);
+        });
+    }
+    update(options) {
+        this.behaviorCollection.forEach((actor) => {
+            if (!this.activeBehaviors[actor.id]) {
+                this.setUpBehavior(actor);
+            }
+            this.activeBehaviors[actor.id].forEach((behavior) => behavior.update?.(options));
+        });
+    }
+}
+BehaviorSystem.systemName = 'BehaviorSystem';

package/build/contrib/systems/{script-system → behavior-system}/types.d.ts

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

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

@@ -0,0 +1,3 @@
+export class Behavior {
+    static behaviorName;
+}

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

@@ -1,12 +1,12 @@
-import type { Actor, ActorCollection } from '../../../engine/actor';
+import type { Actor } from '../../../engine/actor';
 interface CameraServiceOptions {
-    cameraCollection: ActorCollection;
-    onCameraUpdate: () => void;
+    onCameraUpdate: (actor: Actor) => void;
+    findCurrentCamera: () => Actor | undefined;
 }
 export declare class CameraService {
-    private cameraCollection;
     private onCameraUpdate;
-    constructor({ cameraCollection, onCameraUpdate }: CameraServiceOptions);
+    private findCurrentCamera;
+    constructor({ onCameraUpdate, findCurrentCamera }: CameraServiceOptions);
     setCurrentCamera(actor: Actor): void;
     getCurrentCamera(): Actor | undefined;
 }