dacha 0.18.0-alpha.5 → 0.18.0-alpha.7

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

@@ -30,7 +30,7 @@ export interface AudioSourceConfig {
  * audioSource.volume = 0.5; // Set volume to 50%
  *
  * // Play the audio
- * actor.dispatchEvent(PlayAudio);
+ * audioSource.playing = true;
  * ```
  *
  * @category Components

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

@@ -23,7 +23,7 @@ import { Component } from '../../../engine/component';
  * audioSource.volume = 0.5; // Set volume to 50%
  *
  * // Play the audio
- * actor.dispatchEvent(PlayAudio);
+ * audioSource.playing = true;
  * ```
  *
  * @category Components

package/build/contrib/components/character-body/index.d.ts

@@ -26,6 +26,8 @@ export declare class CharacterBody extends Component {
     private _up;
     /** @internal Pending one-step displacement consumed by CharacterController */
     _displacement: Vector2;
+    /** @internal Whether CharacterController should run overlap recovery */
+    _needsRecovery: boolean;
     /** Controls contact classification and whether ground snapping is enabled. */
     motionMode: CharacterMotionMode;
     /** Desired character velocity in world units per second */
@@ -36,7 +38,7 @@ export declare class CharacterBody extends Component {
     maxSlopeAngle: number;
     /** Maximum sweep/slide collision iterations used during one fixed update */
     maxSlides: number;
-    /** Maximum overlap depenetration iterations used before sweep/slide movement */
+    /** Maximum overlap depenetration iterations used when recovery is requested */
     maxRecoveries: number;
     /** Distance used to probe opposite upDirection and keep ground contact over small gaps */
     groundSnapDistance: number;
@@ -63,4 +65,8 @@ export declare class CharacterBody extends Component {
      * update and is already expected to be scaled by delta time.
      */
     move(displacement: Vector2): void;
+    /**
+     * Requests overlap depenetration on the next CharacterController update.
+     */
+    recover(): void;
 }

package/build/contrib/components/character-body/index.js

@@ -13,6 +13,8 @@ export class CharacterBody extends Component {
     _up;
     /** @internal Pending one-step displacement consumed by CharacterController */
     _displacement;
+    /** @internal Whether CharacterController should run overlap recovery */
+    _needsRecovery;
     /** Controls contact classification and whether ground snapping is enabled. */
     motionMode;
     /** Desired character velocity in world units per second */
@@ -23,7 +25,7 @@ export class CharacterBody extends Component {
     maxSlopeAngle;
     /** Maximum sweep/slide collision iterations used during one fixed update */
     maxSlides;
-    /** Maximum overlap depenetration iterations used before sweep/slide movement */
+    /** Maximum overlap depenetration iterations used when recovery is requested */
     maxRecoveries;
     /** Distance used to probe opposite upDirection and keep ground contact over small gaps */
     groundSnapDistance;
@@ -43,6 +45,7 @@ export class CharacterBody extends Component {
         super();
         this._up = new Vector2(0, -1);
         this._displacement = new Vector2(0, 0);
+        this._needsRecovery = true;
         this.upDirection = new Vector2(config.upDirectionX ?? 0, config.upDirectionY ?? -1);
         this.motionMode = config.motionMode ?? 'surface';
         this.disabled = config.disabled ?? false;
@@ -77,5 +80,11 @@ export class CharacterBody extends Component {
     move(displacement) {
         this._displacement.add(displacement);
     }
+    /**
+     * Requests overlap depenetration on the next CharacterController update.
+     */
+    recover() {
+        this._needsRecovery = true;
+    }
 }
 CharacterBody.componentName = 'CharacterBody';

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

@@ -65,33 +65,6 @@ export declare const CollisionLeave = "CollisionLeave";
  * @category Events
  */
 export declare const CharacterHit = "CharacterHit";
-/**
- * Dispatched to play audio on an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export declare const PlayAudio = "PlayAudio";
-/**
- * Dispatched to stop audio on an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export declare const StopAudio = "StopAudio";
-/**
- * Dispatched to set audio volume
- *
- * @event
- * @type {SetAudioSourceVolumeEvent} (for actors) or {@link SetAudioGroupVolumeEvent} (for whole groups)
- *
- * @category Events
- */
-export declare const SetAudioVolume = "SetAudioVolume";
 /** Event signature for the {@link MouseInput} event
  *
  * @category Events
@@ -112,16 +85,6 @@ export type GameStatsUpdateEvent = WorldEvent<{
     /** Current number of actors in the scene */
     actorsCount: number;
 }>;
-/** Event signature for the {@link SetAudioVolume} event when used on world level
- *
- * @category Events
- */
-export type SetAudioGroupVolumeEvent = WorldEvent<{
-    /** Audio group name to set volume for */
-    group: string;
-    /** Volume value (0.0 to 1.0) */
-    value: number;
-}>;
 /** Event signature for mouse control events
  *
  * @category Events
@@ -183,29 +146,17 @@ export type CharacterHitEvent = ActorEvent<{
     /** Surface classification used by the character controller */
     kind: 'ground' | 'wall' | 'ceiling';
 }>;
-/** Event signature for the {@link SetAudioVolume} event when used on actor level
- *
- * @category Events
- */
-export type SetAudioSourceVolumeEvent = ActorEvent<{
-    /** Volume value (0.0 to 1.0) */
-    value: number;
-}>;
 declare module '../../types/events' {
     interface WorldEventMap {
         [MouseInput]: MouseInputEvent;
         [KeyboardInput]: KeyboardInputEvent;
         [GameStatsUpdate]: GameStatsUpdateEvent;
-        [SetAudioVolume]: SetAudioGroupVolumeEvent;
     }
     interface ActorEventMap {
         [CollisionEnter]: CollisionEnterEvent;
         [CollisionStay]: CollisionStayEvent;
         [CollisionLeave]: CollisionLeaveEvent;
         [CharacterHit]: CharacterHitEvent;
-        [PlayAudio]: ActorEvent;
-        [StopAudio]: ActorEvent;
-        [SetAudioVolume]: SetAudioSourceVolumeEvent;
     }
 }
 export {};

package/build/contrib/events/index.js

@@ -61,30 +61,3 @@ export const CollisionLeave = 'CollisionLeave';
  * @category Events
  */
 export const CharacterHit = 'CharacterHit';
-/**
- * Dispatched to play audio on an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export const PlayAudio = 'PlayAudio';
-/**
- * Dispatched to stop audio on an actor
- *
- * @event
- * @type {ActorEvent}
- *
- * @category Events
- */
-export const StopAudio = 'StopAudio';
-/**
- * Dispatched to set audio volume
- *
- * @event
- * @type {SetAudioSourceVolumeEvent} (for actors) or {@link SetAudioGroupVolumeEvent} (for whole groups)
- *
- * @category Events
- */
-export const SetAudioVolume = 'SetAudioVolume';

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

@@ -0,0 +1,38 @@
+export interface AudioAPIHandlers {
+    getGroupVolume(group: string): number;
+    setGroupVolume(group: string, volume: number): void;
+}
+/**
+ * API that provides synchronous audio mixer controls.
+ *
+ * Actor playback is controlled through AudioSource component state.
+ * This API is intended for global audio state such as group and master volume.
+ *
+ * @category Systems
+ */
+export declare class AudioAPI {
+    private handlers;
+    constructor(handlers: AudioAPIHandlers);
+    /**
+     * Current master volume.
+     */
+    get masterVolume(): number;
+    /**
+     * Sets the master volume.
+     */
+    set masterVolume(volume: number);
+    /**
+     * Returns the volume for an audio group.
+     *
+     * @param group - Audio group name
+     * @returns Audio group volume
+     */
+    getGroupVolume(group: string): number;
+    /**
+     * Sets the volume for an audio group.
+     *
+     * @param group - Audio group name
+     * @param volume - New group volume
+     */
+    setGroupVolume(group: string, volume: number): void;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * API that provides synchronous audio mixer controls.
+ *
+ * Actor playback is controlled through AudioSource component state.
+ * This API is intended for global audio state such as group and master volume.
+ *
+ * @category Systems
+ */
+export class AudioAPI {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    /**
+     * Current master volume.
+     */
+    get masterVolume() {
+        return this.getGroupVolume('master');
+    }
+    /**
+     * Sets the master volume.
+     */
+    set masterVolume(volume) {
+        this.setGroupVolume('master', volume);
+    }
+    /**
+     * Returns the volume for an audio group.
+     *
+     * @param group - Audio group name
+     * @returns Audio group volume
+     */
+    getGroupVolume(group) {
+        return this.handlers.getGroupVolume(group);
+    }
+    /**
+     * Sets the volume for an audio group.
+     *
+     * @param group - Audio group name
+     * @param volume - New group volume
+     */
+    setGroupVolume(group, volume) {
+        this.handlers.setGroupVolume(group, volume);
+    }
+}

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

@@ -25,13 +25,14 @@ export declare class AudioSystem extends WorldSystem {
     private loadAudio;
     private handleActorAdd;
     private handleActorRemove;
-    private handlePlayAudio;
-    private handleStopAudio;
-    private handleSetAudioVolume;
     private resumeIfSuspended;
+    private getGroup;
+    private getGroupVolume;
+    private setGroupVolume;
     private initAudio;
     private playAudio;
     private stopAudio;
     private updateAudio;
     update(): void;
 }
+export { AudioAPI } from './api';

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

@@ -1,9 +1,9 @@
 import { WorldSystem } from '../../../engine/system';
-import { Actor, ActorQuery } from '../../../engine/actor';
+import { 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 { AudioAPI } from './api';
 import { getAllSources, getAllTemplateSources, loadAudio } from './utils';
 const MASTER_GROUP = 'master';
 const VOLUME_TOLERANCE = 0.001;
@@ -44,9 +44,13 @@ export class AudioSystem extends WorldSystem {
         }, { [MASTER_GROUP]: masterAudioGroup });
         this.audioStore = new CacheStore();
         this.audioState = new Map();
-        this.world.addEventListener(PlayAudio, this.handlePlayAudio);
-        this.world.addEventListener(StopAudio, this.handleStopAudio);
-        this.world.addEventListener(SetAudioVolume, this.handleSetAudioVolume);
+        const audioApi = new AudioAPI({
+            getGroupVolume: (group) => this.getGroupVolume(group),
+            setGroupVolume: (group, volume) => {
+                this.setGroupVolume(group, volume);
+            },
+        });
+        this.world.systemApi.register(audioApi);
         window.addEventListener('click', this.resumeIfSuspended, { once: true });
         window.addEventListener('keydown', this.resumeIfSuspended, { once: true });
         window.addEventListener('touchstart', this.resumeIfSuspended, {
@@ -96,9 +100,6 @@ export class AudioSystem extends WorldSystem {
     }
     onWorldDestroy() {
         void this.audioContext.close();
-        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);
@@ -129,28 +130,6 @@ export class AudioSystem extends WorldSystem {
         this.audioStore.release(src);
         this.stopAudio(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().catch((err) => {
@@ -158,6 +137,19 @@ export class AudioSystem extends WorldSystem {
             });
         }
     };
+    getGroup(group) {
+        const audioGroup = this.audioGroups[group];
+        if (!audioGroup) {
+            throw new Error(`Can't find audio group with the following name: ${group}`);
+        }
+        return audioGroup;
+    }
+    getGroupVolume(group) {
+        return this.getGroup(group).gain.value;
+    }
+    setGroupVolume(group, volume) {
+        this.getGroup(group).gain.value = volume;
+    }
     initAudio(actor) {
         const audioSource = actor.getComponent(AudioSource);
         if (audioSource.autoplay) {
@@ -217,6 +209,7 @@ export class AudioSystem extends WorldSystem {
         if (Math.abs(audioSource.volume - audioState.properties.volume) >
             VOLUME_TOLERANCE) {
             audioState.gainNode.gain.value = audioSource.volume;
+            audioState.properties.volume = audioSource.volume;
         }
     }
     update() {
@@ -236,3 +229,4 @@ export class AudioSystem extends WorldSystem {
     }
 }
 AudioSystem.systemName = 'AudioSystem';
+export { AudioAPI } from './api';

package/build/contrib/systems/character-controller/index.d.ts

@@ -21,8 +21,8 @@ export declare class CharacterController extends SceneSystem {
     private isRecoverableOverlap;
     private resetGroundState;
     private resetState;
-    private castAll;
     private cast;
+    private castMotion;
     private castGround;
     private recoverOverlaps;
     private handleHit;

package/build/contrib/systems/character-controller/index.js

@@ -71,15 +71,15 @@ export class CharacterController extends SceneSystem {
         character.onWall = false;
         character.onCeiling = false;
     }
-    castAll(actor, position, displacement) {
+    cast(actor, position, displacement, hitFilter) {
+        if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
+            return null;
+        }
         const physicsApi = this.world.systemApi.get(PhysicsAPI);
         const character = actor.getComponent(CharacterBody);
         const transform = actor.getComponent(Transform);
         const distance = displacement.magnitude;
-        if (distance <= DISTANCE_EPSILON) {
-            return [];
-        }
-        return physicsApi.castActorAll({
+        return physicsApi.castActor({
             actor,
             offset: {
                 x: position.x - transform.world.position.x,
@@ -87,35 +87,28 @@ export class CharacterController extends SceneSystem {
             },
             direction: displacement,
             maxDistance: distance + character.skinWidth,
+            hitFilter,
         });
     }
-    cast(actor, position, displacement) {
-        const hits = this.castAll(actor, position, displacement);
-        for (const hit of hits) {
+    castMotion(actor, position, displacement) {
+        return this.cast(actor, position, displacement, (hit) => {
             if (hit.distance <= DISTANCE_EPSILON &&
                 VectorOps.dotProduct(displacement, hit.normal) > DISTANCE_EPSILON) {
-                continue;
-            }
-            if (this.isBlockingHit(actor, hit)) {
-                return hit;
+                return false;
             }
-        }
-        return null;
+            return this.isBlockingHit(actor, hit);
+        });
     }
     castGround(actor, position, displacement) {
-        const hits = this.castAll(actor, position, displacement);
-        for (const hit of hits) {
-            if (this.isBlockingHit(actor, hit) &&
-                this.isWalkable(actor, hit.normal)) {
-                return hit;
-            }
-        }
-        return null;
+        return this.cast(actor, position, displacement, (hit) => this.isBlockingHit(actor, hit) && this.isWalkable(actor, hit.normal));
     }
     recoverOverlaps(actor, position) {
-        const physicsApi = this.world.systemApi.get(PhysicsAPI);
         const character = actor.getComponent(CharacterBody);
+        if (!character._needsRecovery) {
+            return;
+        }
         const transform = actor.getComponent(Transform);
+        const physicsApi = this.world.systemApi.get(PhysicsAPI);
         for (let i = 0; i < character.maxRecoveries; i += 1) {
             const hits = physicsApi.overlapActor({
                 actor,
@@ -138,6 +131,7 @@ export class CharacterController extends SceneSystem {
                 recovered = true;
             }
             if (!recovered) {
+                character._needsRecovery = false;
                 break;
             }
         }
@@ -176,13 +170,16 @@ export class CharacterController extends SceneSystem {
         });
     }
     move(actor, position, displacement) {
+        if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
+            return;
+        }
         const character = actor.getComponent(CharacterBody);
         for (let i = 0; i < character.maxSlides; i += 1) {
-            const distance = displacement.magnitude;
-            if (distance <= DISTANCE_EPSILON) {
+            if (displacement.squaredMagnitude <= DISTANCE_EPSILON) {
                 break;
             }
-            const hit = this.cast(actor, position, displacement);
+            const distance = displacement.magnitude;
+            const hit = this.castMotion(actor, position, displacement);
             if (!hit) {
                 position.add(displacement);
                 break;
@@ -243,17 +240,20 @@ export class CharacterController extends SceneSystem {
                 character._displacement.multiplyNumber(0);
                 return;
             }
+            const position = new Vector2(transform.world.position.x, transform.world.position.y);
+            this.recoverOverlaps(actor, position);
             const displacement = character.velocity
                 .clone()
                 .multiplyNumber(deltaTimeInSeconds)
                 .add(character._displacement);
             const movingUp = VectorOps.dotProduct(displacement, character.upDirection) >
                 SNAP_EPSILON;
-            const position = new Vector2(transform.world.position.x, transform.world.position.y);
-            this.recoverOverlaps(actor, position);
             this.move(actor, position, displacement);
             this.updateGroundState(actor, position, movingUp || character.motionMode === 'free');
-            rigidBody.movePosition(position);
+            if (Math.abs(position.x - transform.world.position.x) > DISTANCE_EPSILON ||
+                Math.abs(position.y - transform.world.position.y) > DISTANCE_EPSILON) {
+                rigidBody.movePosition(position);
+            }
             character._displacement.multiplyNumber(0);
         });
         this.oneWayValidator.lateUpdate();

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

@@ -11,5 +11,5 @@ export { BehaviorSystem, Behavior } from './behavior-system';
 export type { BehaviorOptions } from './behavior-system';
 export { UIBridge } from './ui-bridge';
 export type { UIOptions, UIInitFn, UIDestroyFn, LoadUIFn } from './ui-bridge';
-export { AudioSystem } from './audio-system';
+export { AudioSystem, AudioAPI } from './audio-system';
 export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

package/build/contrib/systems/index.js

@@ -9,5 +9,5 @@ export { MouseInputSystem } from './mouse-input-system';
 export { PhysicsSystem, PhysicsAPI } from './physics-system';
 export { BehaviorSystem, Behavior } from './behavior-system';
 export { UIBridge } from './ui-bridge';
-export { AudioSystem } from './audio-system';
+export { AudioSystem, AudioAPI } from './audio-system';
 export { Renderer, RendererAPI, FilterEffect, Shader } from './renderer';

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

@@ -0,0 +1,28 @@
+import type { AABB } from '../types';
+export type DynamicAABBTreeEntryId = number;
+export declare class DynamicAABBTree<T> {
+    private root;
+    private nodesById;
+    private freeInternalNodes;
+    private queryStack;
+    private nextId;
+    get size(): number;
+    insert(aabb: AABB, value: T): DynamicAABBTreeEntryId;
+    update(id: DynamicAABBTreeEntryId, aabb: AABB): void;
+    remove(id: DynamicAABBTreeEntryId): void;
+    query(aabb: AABB, visitor: (value: T) => unknown): void;
+    queryAll(aabb: AABB, output?: T[]): T[];
+    clear(): void;
+    private createNode;
+    private getNode;
+    private insertLeaf;
+    private removeLeaf;
+    private createInternalNode;
+    private releaseInternalNode;
+    private findBestSibling;
+    private getDescentCost;
+    private fixAncestors;
+    private balance;
+    private rotateLeft;
+    private rotateRight;
+}