@woosh/meep-engine 2.48.1 → 2.48.5

package/src/engine/intelligence/behavior/util/behavior_traverse_tree.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../../core/assert.js";
+
 /**
  *
  * @param {Behavior|CompositeBehavior|AbstractDecoratorBehavior} root
@@ -6,6 +8,12 @@
  */
 export function behavior_traverse_tree(root, visitor, thisArg) {
 
+    assert.defined(root, 'root');
+    assert.notNull(root, 'root');
+    assert.equal(root.isBehavior, true, 'root.isBehavior !== true');
+
+    assert.isFunction(visitor, 'visitor');
+
     const should_continue = visitor.call(thisArg, root);
 
     if (should_continue === false) {

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -13,6 +13,8 @@ import { Transform } from '../../../ecs/transform/Transform.js';
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { PathFollowerEventType } from "./PathFollowerEventType.js";
 import { PathFollowerFlags } from "./PathFollowerFlags.js";
+import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
+import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 
 const v3_forward = new Vector3();
 const v3_temp1 = new Vector3();
@@ -127,6 +129,12 @@ class PathFollowingSystem extends System {
 
         this.dependencies = [PathFollower];
 
+        this.components_used = [
+            ResourceAccessSpecification.from(PathFollower, ResourceAccessKind.Read | ResourceAccessKind.Write),
+            ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+            ResourceAccessSpecification.from(Path, ResourceAccessKind.Read),
+        ];
+
         /**
          *
          * @type {number}

package/src/engine/network/RemoteController.js

@@ -1,138 +1,114 @@
 import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
-import BinaryBufferDeSerializer from "../ecs/storage/BinaryBufferDeSerializer.js";
-import { BinaryObjectSerializationAdapter } from "../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
+import { assert } from "../../core/assert.js";
 
-class LocalAPI {
+/*
+ packet header structure
+    - TAG       : 1 x utf8 string
+    - ID        : 1 x uint32
+    - PAYLOAD   : N x bytes
+ */
+
+export class RemoteController {
     /**
      *
-     * @type {Engine|null}
+     * @type {WebSocket|null}
      */
-    engine = null;
+    #socket = null;
 
-    _object_serde = new BinaryObjectSerializationAdapter();
+    #handlers = {};
 
-    get _registry() {
-        return this.engine.binarySerializationRegistry;
-    }
+    #bound_event_handler = this.#handle_message_event.bind(this)
 
     /**
      *
-     * @return {EntityComponentDataset}
-     * @private
+     * @param {string} tag
+     * @param {function(BinaryBuffer):Promise} handler
+     * @param {*} thisArg
      */
-    get _current_dataset() {
-        return this.engine.entityManager.dataset;
-    }
-
-    /**
-     * Server sent us a new world state
-     * @param {BinaryBuffer} buffer
-     */
-    async writeCurrentSceneDataset(buffer) {
-        const deSerializer = new BinaryBufferDeSerializer();
-
-        const engine = this.engine;
-
-        deSerializer.registry = this._registry;
+    addHandler(tag, handler, thisArg) {
+        const existing = this.#handlers[tag];
 
-        const ecd = this._current_dataset;
-
-        ecd.clear();
-
-        const task = deSerializer.process(buffer, engine, ecd);
-
-        const p = task.promise();
-
-        engine.executor.run(task);
+        if (existing !== undefined) {
+            throw new Error(`Handler for tag '${tag}' already exists`);
+        }
 
-        await p;
+        this.#handlers[tag] = {
+            method: handler,
+            scope: thisArg
+        };
     }
 
     /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @return {Promise<void>}
+     * NOTE: entire buffer contents will be sent up to current position
+     * @param {string} tag
+     * @param {BinaryBuffer} data
      */
-    async createEntity(buffer) {
-        // create entity on the current scene with a given ID
-
-        const entity_id = buffer.readUintVar();
+    send(tag, data) {
+        assert.isString(tag, 'tag');
 
-        this._current_dataset.createEntitySpecific(entity_id);
-    }
+        const buffer = new BinaryBuffer();
 
-    async addComponentToEntity(buffer) {
-        const entity_id = buffer.readUintVar();
+        buffer.writeUTF8String(tag);
 
-        this._object_serde.registry = this._registry;
-        const component_instance = this._object_serde.deserialize(buffer);
+        buffer.writeBytes(data.raw_bytes, 0, data.position);
 
-        this._current_dataset.addComponentToEntity(entity_id, component_instance);
+        buffer.trim();
 
+        this.#socket.send(buffer.data);
     }
 
-}
-
-export class RemoteController {
     /**
      *
-     * @type {WebSocket|null}
-     */
-    socket = null;
-
-    localAPI = new LocalAPI();
-
-    /**
-     *
-     * @param {Engine} engine
+     * @param {MessageEvent} event
+     * @private
      */
-    attach(engine) {
-        this.localAPI.engine = engine;
+    async #handle_message_event(event) {
 
-    }
+        /**
+         * @type {ArrayBuffer}
+         */
+        const data = event.data;
 
-    /**
-     *
-     * @param {ArrayBuffer} data
-     * @private
-     */
-    async __handle_message(data) {
         // console.log(`received message `, data);
 
-        const buffer =  BinaryBuffer.fromArrayBuffer(data);
+        const buffer = BinaryBuffer.fromArrayBuffer(data);
 
         // read packet ID
         const packet_id = buffer.readUTF8String();
 
-        console.log(`packet ID: ${packet_id}`);
+        const handler = this.#handlers[packet_id];
 
-        if (this.localAPI[packet_id] === undefined) {
-            console.error(`Local API does not have method '${packet_id}'`);
+        if (handler === undefined) {
+            console.error(`No handler for packet '${packet_id}'`);
             return;
         }
 
         try {
-            await this.localAPI[packet_id](buffer);
+            await handler.method.call(handler.scope, buffer);
         } catch (e) {
             //
             console.error(`Failed to process remote call to '${packet_id}':`, e);
         }
     }
 
+    /**
+     *
+     * @param {WebSocket} v
+     */
+    set socket(v) {
+        if (this.#socket !== null) {
+            // TODO unbind socket
+        }
 
-    startup() {
-        this.socket = new WebSocket('ws://localhost:9020');
+        this.#socket = v;
 
-        this.socket.binaryType = "arraybuffer";
+        this.#socket.binaryType = "arraybuffer";
 
-        this.socket.addEventListener('open', () => {
+        this.#socket.addEventListener('open', () => {
             console.log('socket connection open');
         });
 
-        this.socket.addEventListener('message', (event) => {
-
-
-            this.__handle_message(event.data);
-        });
+        this.#socket.addEventListener('message', this.#bound_event_handler);
     }
+
 }

package/src/engine/network/remoteEditor.js

@@ -2,9 +2,96 @@ import { EngineHarness } from "../EngineHarness.js";
 import { RemoteController } from "./RemoteController.js";
 import { ShadedGeometrySystem } from "../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
 import { initializeGameBinarySerializationRegistry } from "../../../../model/game/GameBinarySerializationRegistry.js";
+import { BinaryObjectSerializationAdapter } from "../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
+import BinaryBufferDeSerializer from "../ecs/storage/BinaryBufferDeSerializer.js";
 
 const harness = new EngineHarness();
 
+class LocalAPI {
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine = null;
+
+    _object_serde = new BinaryObjectSerializationAdapter();
+
+    get _registry() {
+        return this.engine.binarySerializationRegistry;
+    }
+
+    /**
+     *
+     * @return {EntityComponentDataset}
+     * @private
+     */
+    get _current_dataset() {
+        return this.engine.entityManager.dataset;
+    }
+
+    /**
+     * Server sent us a new world state
+     * @param {BinaryBuffer} buffer
+     */
+    async writeCurrentSceneDataset(buffer) {
+        const deSerializer = new BinaryBufferDeSerializer();
+
+        const engine = this.engine;
+
+        deSerializer.registry = this._registry;
+
+        const ecd = this._current_dataset;
+
+        ecd.clear();
+
+        const task = deSerializer.process(buffer, engine, ecd);
+
+        const p = task.promise();
+
+        engine.executor.run(task);
+
+        await p;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @return {Promise<void>}
+     */
+    async createEntity(buffer) {
+        // create entity on the current scene with a given ID
+
+        const entity_id = buffer.readUintVar();
+
+        this._current_dataset.createEntitySpecific(entity_id);
+    }
+
+    async addComponentToEntity(buffer) {
+        const entity_id = buffer.readUintVar();
+
+        this._object_serde.registry = this._registry;
+        const component_instance = this._object_serde.deserialize(buffer);
+
+        this._current_dataset.addComponentToEntity(entity_id, component_instance);
+
+    }
+
+}
+
+/**
+ *
+ * @param {RemoteController} controller
+ * @param {Object} api
+ */
+function attachLocalAPI(controller, api) {
+    for (const apiKey in api) {
+
+        controller.addHandler(apiKey, api[apiKey], api);
+
+    }
+
+}
+
 /**
  *
  * @param {Engine} engine
@@ -20,9 +107,28 @@ async function main(engine) {
 
     const remote = new RemoteController();
 
-    remote.attach(engine);
-    remote.startup();
 
+    const api = new LocalAPI();
+    api.engine = engine;
+
+    Object.getOwnPropertyNames(Object.getPrototypeOf(api))
+        .forEach(name => {
+            if (name.startsWith("_")) {
+                return;
+            }
+
+            if (name === "constructor") {
+                return;
+            }
+
+            if (typeof api[name] !== "function") {
+                return;
+            }
+
+            remote.addHandler(name, api[name], api);
+        });
+
+    remote.socket = new WebSocket('ws://localhost:9020');
 }
 
 harness.initialize({

package/src/engine/sound/SoundEngine.js

@@ -4,93 +4,95 @@
  */
 
 
-/**
- *
- * @constructor
- */
-function SoundEngine() {
+class SoundEngine {
+    /**
+     *
+     * @constructor
+     */
+    constructor() {
+
+        // Fix up prefixing
+        let AudioContext = (
+            window.AudioContext ||
+            null
+        );
+
+        if (!AudioContext) {
+            throw new Error("AudioContext not supported!");
+        }
 
-    // Fix up prefixing
-    let AudioContext = (
-        window.AudioContext ||
-        window.webkitAudioContext ||
-        null
-    );
+        // Create a new audio context.
+        const context = this.context = new AudioContext({
+            /*
+             * The type of playback that the context will be used for, as a value from the AudioContextLatencyCategory enum or a double-precision floating-point value indicating the preferred maximum latency of the context in seconds. The user agent may or may not choose to meet this request; check the value of AudioContext.baseLatency to determine the true latency after creating the context.
+             *
+             * Values:
+             *
+             * "balanced"	    The user agent should balance audio output latency and power consumption when selecting a latency value.
+             * "interactive"	The audio is involved in interactive elements, such as responding to user actions or needing to coincide with visual cues such as a video or game action. The user agent should select the lowest possible latency that doesn't cause glitches in the audio. This is likely to require increased power consumption. This is the default value.
+             * "playback"	    The user agent should select a latency that will maximize playback time by minimizing power consumption at the expense of latency. Useful for non-interactive playback, such as playing music.
+             */
+            latencyHint: 'interactive'
+        });
+
+        //start suspended to keep chrome satisfied, otherwise it prints a warning
+        context.suspend();
+
+        // master volume
+        const gainNode = context.createGain();
+
+        // Dynamic compressor makes quiet sounds louder and loud quieter
+        const compressor = context.createDynamicsCompressor();
+        this.destination = gainNode;
+        gainNode.connect(compressor);
+        compressor.connect(context.destination);
+
+        // master channel
+        Object.defineProperties(this, {
+            volume: {
+                get: function () {
+                    return gainNode.gain.value;
+                },
+                set: function (val) {
+                    gainNode.gain.setValueAtTime(val, context.currentTime, 0);
+                }
+            }
+        });
+    }
 
-    if (!AudioContext) {
-        throw new Error("AudioContext not supported!");
+    /**
+     *
+     * @return {number}
+     */
+    getCurrentTime() {
+        return this.context.currentTime;
     }
 
-    // Create a new audio context.
-    const context = this.context = new AudioContext({
-        /*
-         * The type of playback that the context will be used for, as a value from the AudioContextLatencyCategory enum or a double-precision floating-point value indicating the preferred maximum latency of the context in seconds. The user agent may or may not choose to meet this request; check the value of AudioContext.baseLatency to determine the true latency after creating the context.
-         *
-         * Values:
-         *
-         * "balanced"	    The user agent should balance audio output latency and power consumption when selecting a latency value.
-         * "interactive"	The audio is involved in interactive elements, such as responding to user actions or needing to coincide with visual cues such as a video or game action. The user agent should select the lowest possible latency that doesn't cause glitches in the audio. This is likely to require increased power consumption. This is the default value.
-         * "playback"	    The user agent should select a latency that will maximize playback time by minimizing power consumption at the expense of latency. Useful for non-interactive playback, such as playing music.
-         */
-        latencyHint: 'interactive'
-    });
-
-    //start suspended to keep chrome satisfied, otherwise it prints a warning
-    context.suspend();
-
-    // master volume
-    const gainNode = context.createGain();
-
-    // Dynamic compressor makes quiet sounds louder and loud quieter
-    const compressor = context.createDynamicsCompressor();
-    this.destination = gainNode;
-    gainNode.connect(compressor);
-    compressor.connect(context.destination);
-
-    // master channel
-    Object.defineProperties(this, {
-        volume: {
-            get: function () {
-                return gainNode.gain.value;
-            },
-            set: function (val) {
-                gainNode.gain.setValueAtTime(val, context.currentTime, 0);
-            }
-        }
-    });
-}
+    /**
+     * Audio context needs to be resumed as it is created in suspended state by default
+     * @see https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio
+     * @returns {Promise<void>}
+     */
+    resumeContext() {
+        const pResumed = this.context.resume();
 
-/**
- *
- * @return {number}
- */
-SoundEngine.prototype.getCurrentTime = function () {
-    return this.context.currentTime;
-}
+        return pResumed;
+    }
 
-/**
- * Audio context needs to be resumed as it is created in suspended state by default
- * @see https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio
- * @returns {Promise<void>}
- */
-SoundEngine.prototype.resumeContext = function () {
-    const pResumed = this.context.resume();
+    /**
+     *
+     * @returns {Promise<any>}
+     */
+    start() {
 
-    return pResumed;
-};
+        return new Promise((resolve, reject) => {
+            //don't want for context to be resumed
+            const promise = this.resumeContext();
 
-/**
- *
- * @returns {Promise<any>}
- */
-SoundEngine.prototype.start = function () {
-
-    return new Promise((resolve, reject) => {
-        //don't want for context to be resumed
-        this.resumeContext();
 
-        resolve();
-    });
-};
+            resolve();
+        });
+    }
+}
 
 export default SoundEngine;

package/src/engine/sound/ecs/SoundControllerSystem.js

@@ -7,6 +7,8 @@ import { System } from '../../ecs/System.js';
 import { SoundEmitter } from './emitter/SoundEmitter.js';
 import SoundController from './SoundController.js';
 import { SoundTrack } from "./emitter/SoundTrack.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 
 /**
  *
@@ -30,6 +32,12 @@ class SoundControllerSystem extends System {
     constructor() {
         super();
         this.dependencies = [SoundController];
+
+
+        this.components_used = [
+            ResourceAccessSpecification.from(SoundEmitter, ResourceAccessKind.Write)
+        ];
+
         this.removers = [];
     }
 

package/src/engine/sound/ecs/SoundListenerSystem.js

@@ -10,6 +10,8 @@ import { browserInfo } from "../../Platform.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { noop } from "../../../core/function/Functions.js";
 import { assert } from "../../../core/assert.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 
 const v3 = new Vector3();
 const v3_up = new Vector3();
@@ -92,6 +94,11 @@ class SoundListenerSystem extends System {
         assert.isInstanceOf(context, AudioContext, 'context', 'AudioContext');
 
         this.dependencies = [SoundListener, Transform];
+
+        this.components_used = [
+            ResourceAccessSpecification.from(SoundListener, ResourceAccessKind.Read|ResourceAccessKind.Write)
+        ];
+
         //
         this.webAudioContext = context;