dacha 0.13.0 → 0.14.0

package/build/contrib/components/audio-source/index.d.ts

@@ -0,0 +1,18 @@
+import { Component } from '../../../engine/component';
+export interface AudioSourceConfig {
+    src: string;
+    group: string;
+    looped: boolean;
+    volume: number;
+    autoplay: boolean;
+}
+export declare class AudioSource extends Component {
+    src: string;
+    group: string;
+    looped: boolean;
+    volume: number;
+    autoplay: boolean;
+    playing: boolean;
+    constructor(config: AudioSourceConfig);
+    clone(): AudioSource;
+}

package/build/contrib/components/audio-source/index.js

@@ -0,0 +1,28 @@
+import { Component } from '../../../engine/component';
+export class AudioSource extends Component {
+    src;
+    group;
+    looped;
+    volume;
+    autoplay;
+    playing;
+    constructor(config) {
+        super();
+        this.src = config.src;
+        this.group = config.group;
+        this.looped = config.looped;
+        this.volume = config.volume;
+        this.autoplay = config.autoplay;
+        this.playing = false;
+    }
+    clone() {
+        return new AudioSource({
+            src: this.src,
+            group: this.group,
+            looped: this.looped,
+            volume: this.volume,
+            autoplay: this.autoplay,
+        });
+    }
+}
+AudioSource.componentName = 'AudioSource';

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

@@ -18,3 +18,5 @@ export { ScriptBundle } from './script-bundle';
 export type { ScriptBundleConfig } from './script-bundle';
 export { Light } from './light';
 export type { LightConfig } from './light';
+export { AudioSource } from './audio-source';
+export type { AudioSourceConfig } from './audio-source';

package/build/contrib/components/index.js

@@ -8,3 +8,4 @@ export { Transform } from './transform';
 export { MouseControl } from './mouse-control';
 export { ScriptBundle } from './script-bundle';
 export { Light } from './light';
+export { AudioSource } from './audio-source';

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

@@ -13,6 +13,9 @@ export declare const CollisionLeave = "CollisionLeave";
 export declare const AddForce = "AddForce";
 export declare const AddImpulse = "AddImpulse";
 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<{
@@ -28,6 +31,10 @@ export type CollisionEvent = SceneEvent<{
     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<{
@@ -43,6 +50,9 @@ export type AddForceEvent = ActorEvent<{
 export type AddImpulseEvent = ActorEvent<{
     value: Vector2;
 }>;
+export type SetAudioSourceVolumeEvent = ActorEvent<{
+    value: number;
+}>;
 declare module '../../types/events' {
     interface SceneEventMap {
         [MouseInput]: MouseInputEvent;
@@ -50,6 +60,7 @@ declare module '../../types/events' {
         [SetCamera]: SetCameraEvent;
         [GameStatsUpdate]: GameStatsUpdateEvent;
         [Collision]: CollisionEvent;
+        [SetAudioVolume]: SetAudioGroupVolumeEvent;
     }
     interface ActorEventMap {
         [CollisionEnter]: CollisionEnterEvent;
@@ -58,6 +69,9 @@ declare module '../../types/events' {
         [AddForce]: AddForceEvent;
         [AddImpulse]: AddImpulseEvent;
         [StopMovement]: ActorEvent;
+        [PlayAudio]: ActorEvent;
+        [StopAudio]: ActorEvent;
+        [SetAudioVolume]: SetAudioSourceVolumeEvent;
     }
 }
 export {};

package/build/contrib/events/index.js

@@ -9,3 +9,6 @@ export const CollisionLeave = 'CollisionLeave';
 export const AddForce = 'AddForce';
 export const AddImpulse = 'AddImpulse';
 export const StopMovement = 'StopMovement';
+export const PlayAudio = 'PlayAudio';
+export const StopAudio = 'StopAudio';
+export const SetAudioVolume = 'SetAudioVolume';

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

@@ -0,0 +1,7 @@
+declare class AudioLoader {
+    private cache;
+    constructor();
+    load(url: string): Promise<ArrayBuffer>;
+}
+export declare const audioLoader: AudioLoader;
+export {};

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

@@ -0,0 +1,16 @@
+class AudioLoader {
+    cache;
+    constructor() {
+        this.cache = new Map();
+    }
+    async load(url) {
+        if (this.cache.has(url)) {
+            return structuredClone(this.cache.get(url));
+        }
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        this.cache.set(url, arrayBuffer);
+        return structuredClone(arrayBuffer);
+    }
+}
+export const audioLoader = new AudioLoader();

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

@@ -0,0 +1,27 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class AudioSystem extends System {
+    private templateCollection;
+    private actorCollection;
+    private scene;
+    private audioContext;
+    private audioGroups;
+    private audioCache;
+    private audioState;
+    constructor(options: SystemOptions);
+    load(): Promise<void>;
+    private loadAudio;
+    mount(): void;
+    unmount(): void;
+    private handleActorAdd;
+    private handleActorRemove;
+    private handlePlayAudio;
+    private handleStopAudio;
+    private handleSetAudioVolume;
+    private resumeIfSuspended;
+    private initAudio;
+    private playAudio;
+    private stopAudio;
+    private updateAudio;
+    update(): void;
+}

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

@@ -0,0 +1,195 @@
+import { System } from '../../../engine/system';
+import { Actor, ActorCollection } from '../../../engine/actor';
+import { AddActor, RemoveActor } from '../../../engine/events';
+import { AudioSource } from '../../components';
+import { PlayAudio, StopAudio, SetAudioVolume, } from '../../../events';
+import { audioLoader } from './audio-loader';
+const MASTER_GROUP = 'master';
+const VOLUME_TOLERANCE = 0.001;
+export class AudioSystem extends System {
+    templateCollection;
+    actorCollection;
+    scene;
+    audioContext;
+    audioGroups;
+    audioCache;
+    audioState;
+    constructor(options) {
+        super();
+        const { scene, globalOptions, templateCollection } = options;
+        this.templateCollection = templateCollection;
+        this.actorCollection = new ActorCollection(scene, {
+            components: [AudioSource],
+        });
+        this.scene = scene;
+        this.audioContext = new AudioContext();
+        const masterAudioGroup = new GainNode(this.audioContext);
+        masterAudioGroup.connect(this.audioContext.destination);
+        const audioGroupsOption = globalOptions.audioGroups;
+        const audioGroupsSettings = audioGroupsOption?.groups ?? [];
+        this.audioGroups = audioGroupsSettings.reduce((acc, groupSettings) => {
+            if (groupSettings.name === MASTER_GROUP) {
+                return acc;
+            }
+            const gainNode = new GainNode(this.audioContext);
+            gainNode.gain.value = groupSettings.volume;
+            gainNode.connect(masterAudioGroup);
+            acc[groupSettings.name] = gainNode;
+            return acc;
+        }, { [MASTER_GROUP]: masterAudioGroup });
+        this.audioCache = new Map();
+        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);
+        window.addEventListener('click', this.resumeIfSuspended, { once: true });
+        window.addEventListener('keydown', this.resumeIfSuspended, { once: true });
+        window.addEventListener('touchstart', this.resumeIfSuspended, { once: true });
+    }
+    unmount() {
+        this.audioState.forEach((audioState) => {
+            audioState.sourceNode.stop();
+        });
+        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);
+    }
+    handleActorAdd = (event) => {
+        this.initAudio(event.actor);
+    };
+    handleActorRemove = (event) => {
+        this.stopAudio(event.actor);
+    };
+    handlePlayAudio = (event) => {
+        this.playAudio(event.target);
+    };
+    handleStopAudio = (event) => {
+        this.stopAudio(event.target);
+    };
+    handleSetAudioVolume = (event) => {
+        if (event.target instanceof Actor) {
+            const audioSource = event.target.getComponent(AudioSource);
+            if (!audioSource) {
+                return;
+            }
+            audioSource.volume = event.value;
+        }
+        else {
+            const audioGroup = this.audioGroups[event.group];
+            if (!audioGroup) {
+                return;
+            }
+            audioGroup.gain.value = event.value;
+        }
+    };
+    resumeIfSuspended = () => {
+        if (this.audioContext.state === 'suspended') {
+            void this.audioContext.resume();
+        }
+    };
+    initAudio(actor) {
+        const audioSource = actor.getComponent(AudioSource);
+        if (audioSource.autoplay) {
+            this.playAudio(actor);
+        }
+    }
+    playAudio(actor) {
+        const audioSource = actor.getComponent(AudioSource);
+        if (!audioSource) {
+            return;
+        }
+        const { src, group, volume, looped, playing, } = audioSource;
+        const audioGroupNode = this.audioGroups[group];
+        if (!audioGroupNode || !this.audioCache.has(src)) {
+            return;
+        }
+        if (playing && this.audioState.has(actor.id)) {
+            const prevAudio = this.audioState.get(actor.id);
+            prevAudio.sourceNode.removeEventListener('ended', prevAudio.properties.endedListener);
+            prevAudio.sourceNode.stop();
+            prevAudio.gainNode.disconnect();
+        }
+        const sourceNode = new AudioBufferSourceNode(this.audioContext, {
+            buffer: this.audioCache.get(src),
+            loop: looped,
+        });
+        const gainNode = new GainNode(this.audioContext, {
+            gain: volume,
+        });
+        const endedListener = () => this.stopAudio(actor);
+        sourceNode.connect(gainNode).connect(audioGroupNode);
+        sourceNode.addEventListener('ended', endedListener);
+        sourceNode.start();
+        this.audioState.set(actor.id, {
+            sourceNode,
+            gainNode,
+            properties: { volume, group, endedListener },
+        });
+        audioSource.playing = true;
+    }
+    stopAudio(actor) {
+        const audioSource = actor.getComponent(AudioSource);
+        if (audioSource) {
+            audioSource.playing = false;
+        }
+        const audioState = this.audioState.get(actor.id);
+        if (!audioState) {
+            return;
+        }
+        audioState.sourceNode.stop();
+        audioState.gainNode.disconnect();
+        this.audioState.delete(actor.id);
+    }
+    updateAudio(actor) {
+        const audioSource = actor.getComponent(AudioSource);
+        const audioState = this.audioState.get(actor.id);
+        if (Math.abs(audioSource.volume - audioState.properties.volume) > VOLUME_TOLERANCE) {
+            audioState.gainNode.gain.value = audioSource.volume;
+        }
+    }
+    update() {
+        this.actorCollection.forEach((actor) => {
+            const audioSource = actor.getComponent(AudioSource);
+            const audioState = this.audioState.get(actor.id);
+            if (audioSource.playing && audioState) {
+                this.updateAudio(actor);
+            }
+            if (audioSource.playing && !audioState) {
+                this.playAudio(actor);
+            }
+            if (!audioSource.playing && audioState) {
+                this.stopAudio(actor);
+            }
+        });
+    }
+}
+AudioSystem.systemName = 'AudioSystem';

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

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

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

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

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

@@ -11,3 +11,4 @@ export type { ScriptOptions } from './script-system';
 export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
 export { UiBridge } from './ui-bridge';
 export type { UiInitFnOptions, UiInitFn, UiDestroyFn } from './ui-bridge';
+export { AudioSystem } from './audio-system';

package/build/contrib/systems/index.js

@@ -9,3 +9,4 @@ export { PhysicsSystem } from './physics-system';
 export { ScriptSystem, Script } from './script-system';
 export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
 export { UiBridge } from './ui-bridge';
+export { AudioSystem } from './audio-system';

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

@@ -6,6 +6,7 @@ export { Script, ScriptOptions, ScriptConstructor };
 export declare class ScriptSystem extends System {
     private scriptsCollection;
     private actorSpawner;
+    private globalOptions;
     private scripts;
     private scene;
     private activeScripts;

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

@@ -7,12 +7,13 @@ export { Script };
 export class ScriptSystem extends System {
     scriptsCollection;
     actorSpawner;
+    globalOptions;
     scripts;
     scene;
     activeScripts;
     constructor(options) {
         super();
-        const { actorSpawner, scene, resources = {}, } = options;
+        const { actorSpawner, scene, globalOptions, resources = {}, } = options;
         this.scene = scene;
         this.scriptsCollection = new ActorCollection(scene, {
             components: [
@@ -20,6 +21,7 @@ export class ScriptSystem extends System {
             ],
         });
         this.actorSpawner = actorSpawner;
+        this.globalOptions = globalOptions;
         this.scripts = resources.reduce((acc, script) => {
             if (script.scriptName === undefined) {
                 throw new Error(`Missing scriptName field for ${script.name} script.`);
@@ -53,6 +55,7 @@ export class ScriptSystem extends System {
                 actor,
                 actorSpawner: this.actorSpawner,
                 scene: this.scene,
+                globalOptions: this.globalOptions,
             });
         });
     }

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

@@ -5,6 +5,7 @@ export interface ScriptOptions {
     scene: Scene;
     actor: Actor;
     actorSpawner: ActorSpawner;
+    globalOptions: Record<string, unknown>;
 }
 interface UpdateOptions {
     deltaTime: number;

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

@@ -43,7 +43,7 @@ export class SpriteRenderer extends System {
         this.templateCollection = templateCollection;
         this.window = getWindowNode(windowNodeId);
         this.sortFn = composeSort([
-            createSortByLayer(parseSortingLayers(globalOptions.sortingLayers)),
+            createSortByLayer(parseSortingLayers(globalOptions.sortingLayers?.layers)),
             sortByYAxis,
             sortByXAxis,
             sortByZAxis,

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

@@ -1 +1,2 @@
-export declare const parseSortingLayers: (sortingLayers: unknown) => Array<string>;
+import type { SortingLayer } from '../types';
+export declare const parseSortingLayers: (sortingLayers?: SortingLayer[]) => Array<string>;

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

@@ -1,6 +1,6 @@
 export const parseSortingLayers = (sortingLayers) => {
     if (Array.isArray(sortingLayers)) {
-        return sortingLayers.map((layer) => String(layer));
+        return sortingLayers.map((layer) => String(layer.name));
     }
     return [];
 };

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

@@ -0,0 +1,7 @@
+export type SortingLayer = {
+    id: string;
+    name: string;
+};
+export type SortingLayers = {
+    layers: SortingLayer[];
+};

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

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

package/build/contrib/systems/ui-bridge/index.d.ts

@@ -12,6 +12,7 @@ type ActionFn = (options: ActionFnOptions) => void;
 export interface UiInitFnOptions {
     scene: Scene;
     templateCollection: TemplateCollection;
+    globalOptions: Record<string, unknown>;
     gameStateObserver: Observer;
     pushAction: (action: ActionFn) => void;
 }
@@ -26,6 +27,7 @@ export declare class UiBridge extends System {
     private scene;
     private loadUiApp;
     private templateCollection;
+    private globalOptions;
     private gameStateObserver;
     private actionsQueue;
     private onUiInit?;

package/build/contrib/systems/ui-bridge/index.js

@@ -5,13 +5,14 @@ export class UiBridge extends System {
     scene;
     loadUiApp;
     templateCollection;
+    globalOptions;
     gameStateObserver;
     actionsQueue;
     onUiInit;
     onUiDestroy;
     constructor(options) {
         super();
-        const { actorSpawner, resources, scene, templateCollection, } = options;
+        const { actorSpawner, resources, scene, templateCollection, globalOptions, } = options;
         const loadUiApp = resources?.loadUiApp;
         if (loadUiApp === undefined) {
             throw new Error('UiBridge requires a UI loader. Please specify the loader in the resources section.');
@@ -20,6 +21,7 @@ export class UiBridge extends System {
         this.scene = scene;
         this.actorSpawner = actorSpawner;
         this.templateCollection = templateCollection;
+        this.globalOptions = globalOptions;
         this.gameStateObserver = new Observer();
         this.actionsQueue = [];
     }
@@ -33,6 +35,7 @@ export class UiBridge extends System {
             this.onUiInit({
                 scene: this.scene,
                 templateCollection: this.templateCollection,
+                globalOptions: this.globalOptions,
                 gameStateObserver: this.gameStateObserver,
                 pushAction: this.pushAction.bind(this),
             });

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

@@ -29,7 +29,7 @@ export class SceneProvider {
         this.systems = systems;
         this.resources = resources;
         this.globalOptions = globalOptions.reduce((acc, option) => {
-            acc[option.name] = option.value;
+            acc[option.name] = option.options;
             return acc;
         }, {});
         this.loadedScene = void 0;

package/build/engine/types/config.d.ts

@@ -1,8 +1,6 @@
 export interface GlobalOption {
-    id: string;
     name: string;
-    type: string;
-    value: unknown;
+    options: Record<string, unknown>;
 }
 export interface ComponentConfig {
     name: string;
@@ -11,20 +9,20 @@ export interface ComponentConfig {
 export interface TemplateConfig {
     id: string;
     name: string;
-    components?: Array<ComponentConfig>;
-    children?: Array<TemplateConfig>;
+    components?: ComponentConfig[];
+    children?: TemplateConfig[];
 }
 export interface ActorConfig {
     id: string;
     name: string;
-    children?: Array<ActorConfig>;
-    components?: Array<ComponentConfig>;
+    children?: ActorConfig[];
+    components?: ComponentConfig[];
     templateId?: string;
 }
 export interface LevelConfig {
     id: string;
     name: string;
-    actors: Array<ActorConfig>;
+    actors: ActorConfig[];
 }
 export interface SystemConfig {
     name: string;
@@ -34,14 +32,14 @@ export interface SceneConfig {
     id: string;
     name: string;
     levelId: string | null;
-    systems: Array<SystemConfig>;
+    systems: SystemConfig[];
 }
 export interface Config {
-    scenes: Array<SceneConfig>;
-    levels: Array<LevelConfig>;
-    templates: Array<TemplateConfig>;
-    loaders: Array<SceneConfig>;
+    scenes: SceneConfig[];
+    levels: LevelConfig[];
+    templates: TemplateConfig[];
+    loaders: SceneConfig[];
     startSceneId: string | null;
     startLoaderId: string | null;
-    globalOptions: Array<GlobalOption>;
+    globalOptions: GlobalOption[];
 }

package/build/events/index.d.ts

@@ -1,4 +1,4 @@
 export { AddActor, RemoveActor, LoadScene, LoadLevel, } from '../engine/events';
 export type { AddActorEvent, RemoveActorEvent, LoadSceneEvent, LoadLevelEvent, } from '../engine/events';
-export { SetCamera, GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, } from '../contrib/events';
-export type { SetCameraEvent, GameStatsUpdateEvent, KeyboardInputEvent, MouseInputEvent, KeyboardControlEvent, MouseControlEvent, CollisionEnterEvent, CollisionStayEvent, CollisionLeaveEvent, AddForceEvent, AddImpulseEvent, } from '../contrib/events';
+export { SetCamera, GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';
+export type { SetCameraEvent, GameStatsUpdateEvent, KeyboardInputEvent, MouseInputEvent, KeyboardControlEvent, MouseControlEvent, CollisionEnterEvent, CollisionStayEvent, CollisionLeaveEvent, AddForceEvent, AddImpulseEvent, SetAudioGroupVolumeEvent, SetAudioSourceVolumeEvent, } from '../contrib/events';

package/build/events/index.js

@@ -1,2 +1,2 @@
 export { AddActor, RemoveActor, LoadScene, LoadLevel, } from '../engine/events';
-export { SetCamera, GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, } from '../contrib/events';
+export { SetCamera, GameStatsUpdate, KeyboardInput, MouseInput, CollisionEnter, CollisionStay, CollisionLeave, AddForce, AddImpulse, PlayAudio, StopAudio, SetAudioVolume, } from '../contrib/events';

package/package.json

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