@woosh/meep-engine 2.54.0 → 2.56.0

package/src/engine/input/devices/KeyboardDevice.spec.js

@@ -0,0 +1,12 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import KeyboardDevice from "./KeyboardDevice.js";
+
+test("constructor does not throw", () => {
+    const el = document.createElement('div');
+    el.setAttribute('tabindex', "0");
+
+    new KeyboardDevice(el);
+});

package/src/engine/input/devices/PointerDevice.js

@@ -322,9 +322,13 @@ export function readPositionFromMouseEvent(result, event, source = event.target)
     result.set(x, y);
 }
 
+/**
+ * Abstracts Mouse and Touch interfaces as single "pointer" device.
+ */
 export class PointerDevice {
 
     /**
+     * Current live position of the pointer
      * @readonly
      * @type {Vector2}
      */
@@ -373,7 +377,7 @@ export class PointerDevice {
     isRunning = false;
 
     /**
-     * The MouseEvent.buttons is a 32bit field, which means we can encode up to 32 buttons
+     * The {@link MouseEvent.buttons} is a 32bit field, which means we can encode up to 32 buttons
      * @readonly
      * @type {InputDeviceSwitch[]}
      */

package/src/engine/input/ecs/components/Input.js

@@ -4,12 +4,28 @@ import { InputBinding } from "../ism/InputBinding.js";
 
 
 export class Input {
-    constructor() {
-        /**
-         *
-         * @type {List<InputBinding>}
-         */
-        this.bindings = new List();
+
+    /**
+     * @readonly
+     * @type {List<InputBinding>}
+     */
+    bindings = new List();
+
+    /**
+     *
+     * @param {Input} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.bindings.equals(other.bindings);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return this.bindings.hash();
     }
 
     /**
@@ -19,10 +35,20 @@ export class Input {
      * @returns {boolean}
      */
     exists(path, event) {
-        assert.typeOf(path, 'string', "path");
-        assert.typeOf(event, 'string', "event");
+        assert.isString(path, "path");
+        assert.isString(event, "event");
+
+        const bindings = this.bindings;
+        const count = bindings.length;
+        for (let i = 0; i < count; i++) {
+            const binding = bindings.get(i);
+
+            if (binding.path === path && binding.event === event) {
+                return true;
+            }
+        }
 
-        return this.bindings.some(b => b.path === path && b.event === event);
+        return false;
     }
 
     /**
@@ -32,8 +58,8 @@ export class Input {
      * @returns {boolean}
      */
     bind(path, event) {
-        assert.typeOf(path, 'string', path);
-        assert.typeOf(event, 'string', path);
+        assert.isString(path, "path");
+        assert.isString(event, "event");
 
         if (this.exists(path, event)) {
             //binding exists

package/src/engine/input/ecs/ism/InputBinding.js

@@ -1,18 +1,18 @@
 import { assert } from "../../../../core/assert.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 
 export class InputBinding {
-    constructor() {
-        /**
-         *
-         * @type {string}
-         */
-        this.path = "";
-        /**
-         *
-         * @type {string}
-         */
-        this.event = "";
-    }
+
+    /**
+     *
+     * @type {string}
+     */
+    path = "";
+    /**
+     *
+     * @type {string}
+     */
+    event = "";
 
     /**
      *
@@ -27,6 +27,24 @@ export class InputBinding {
         this.event = event;
     }
 
+    /**
+     *
+     * @param {InputBinding} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.event === other.event
+            && this.path === other.path;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return computeStringHash(this.event) ^ computeStringHash(this.path);
+    }
+
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/intelligence/behavior/ecs/BehaviorComponentSerializationAdapter.js

@@ -4,18 +4,15 @@ import { SequenceBehavior } from "../composite/SequenceBehavior.js";
 import { SucceedingBehavior } from "../primitive/SucceedingBehavior.js";
 
 export class BehaviorComponentSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = BehaviorComponent;
-        this.version = 0;
+    klass = BehaviorComponent;
+    version = 0;
 
-        /**
-         *
-         * @type {BinaryObjectSerializationAdapter}
-         */
-        this.objectAdapter = null;
-    }
+    /**
+     *
+     * @type {BinaryObjectSerializationAdapter}
+     */
+    objectAdapter = null;
 
     /**
      *

package/src/engine/intelligence/behavior/ecs/WaitForEventBehaviorSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/Bin
 import { WaitForEventBehavior } from "./WaitForEventBehavior.js";
 
 export class WaitForEventBehaviorSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = WaitForEventBehavior;
-        this.version = 0;
-    }
+    klass = WaitForEventBehavior;
+    version = 0;
 
     /**
      *

package/src/engine/intelligence/behavior/primitive/FailingBehaviorSerializationAdapter.js

@@ -2,12 +2,8 @@ import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/Bin
 import { FailingBehavior } from "./FailingBehavior.js";
 
 export class FailingBehaviorSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = FailingBehavior;
-        this.version = 0;
-    }
+    klass = FailingBehavior;
+    version = 0;
 
     /**
      *

package/src/engine/intelligence/behavior/primitive/SucceedingBehaviorSerializationAdapter.js

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/Bin
 import { SucceedingBehavior } from "./SucceedingBehavior.js";
 
 export class SucceedingBehaviorSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = SucceedingBehavior;
-        this.version = 0;
-    }
+    klass = SucceedingBehavior;
+    version = 0;
 
     /**
      *

package/src/engine/intelligence/blackboard/BlackboardSerializationAdapter.js

@@ -4,12 +4,9 @@ import { Blackboard } from "./Blackboard.js";
 import { BlackboardValue } from "./BlackboardValue.js";
 
 export class BlackboardSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = Blackboard;
-        this.version = 0;
-    }
+    klass = Blackboard;
+    version = 0;
 
     /**
      *

package/src/engine/knowledge/database/StaticKnowledgeDatabase.js

@@ -18,22 +18,21 @@ export const StaticKnowledgeState = {
 };
 
 export class StaticKnowledgeDatabase {
-    constructor() {
 
-        /**
-         *
-         * @type {ObservedEnum<StaticKnowledgeState>}
-         */
-        this.__state = new ObservedEnum(StaticKnowledgeState.Initial, StaticKnowledgeState);
+    /**
+     *
+     * @type {ObservedEnum<StaticKnowledgeState>}
+     */
+    __state = new ObservedEnum(StaticKnowledgeState.Initial, StaticKnowledgeState);
 
 
-        /**
-         *
-         * @type {StaticKnowledgeDataTableDescriptor[]}
-         * @private
-         */
-        this.__specs = [];
-    }
+    /**
+     *
+     * @type {StaticKnowledgeDataTableDescriptor[]}
+     * @private
+     */
+    __specs = [];
+    
 
     /**
      * Reset database, drop all table data

package/src/engine/knowledge/database/StaticKnowledgeDatabase.spec.js

@@ -0,0 +1,23 @@
+import { StaticKnowledgeDatabase } from "./StaticKnowledgeDatabase.js";
+import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
+
+test("constructor does not throw", () => {
+    new StaticKnowledgeDatabase()
+});
+
+test("reset empty", () => {
+    const database = new StaticKnowledgeDatabase();
+
+    database.reset();
+});
+
+test("add/get", () => {
+    const database = new StaticKnowledgeDatabase();
+
+    const table = new StaticKnowledgeDataTable();
+    database.add("x", "y", table)
+
+    const actual = database.getTable('x');
+
+    expect(actual).toBe(table);
+});

package/src/engine/navigation/ecs/components/PathSerializationAdapter.js

@@ -6,12 +6,9 @@ import Path from "./Path.js";
 const v0 = new Vector3();
 
 export class PathSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = Path;
-        this.version = 3;
-    }
+    klass = Path;
+    version = 3;
 
     /**
      *

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

@@ -2,12 +2,9 @@ import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/Bin
 import PathFollower from "./PathFollower.js";
 
 export class PathFollowerSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
 
-        this.klass = PathFollower;
-        this.version = 3;
-    }
+    klass = PathFollower;
+    version = 3;
 
     /**
      *

package/src/engine/navigation/grid/find_path_on_grid_astar.spec.js

@@ -5,3 +5,28 @@ test("sanity check on 1x1 grid", () => {
 
     expect(path).toEqual([0]);
 });
+
+test("sanity check on 2x1 grid", () => {
+    const path = find_path_on_grid_astar(
+        [0, 0], 2, 1,
+        0, 1,
+        0, 0, 1
+    );
+
+    expect(path).toEqual([0, 1]);
+});
+
+test("sanity check on 2x2 grid", () => {
+
+    const path = find_path_on_grid_astar(
+        [
+            0, 0,
+            1, 0
+        ],
+        2, 2,
+        0, 3,
+        0, 0, 1
+    );
+
+    expect(path).toEqual([0, 1, 3]);
+});

package/src/engine/options/OptionAbstract.js

@@ -1,4 +1,10 @@
 export class OptionAbstract {
+    /**
+     *
+     * @type {OptionGroup|null}
+     */
+    parent = null;
+
     /**
      *
      * @param {string} id
@@ -11,11 +17,6 @@ export class OptionAbstract {
          */
         this.id = id;
 
-        /**
-         *
-         * @type {OptionGroup|null}
-         */
-        this.parent = null;
     }
 
     /**

package/src/engine/options/OptionGroup.js

@@ -8,20 +8,12 @@ function isOption(c) {
 }
 
 export class OptionGroup extends OptionAbstract {
+
     /**
      *
-     * @param {string} id
-     * @constructor
+     * @type {Array<OptionGroup|Option>}
      */
-    constructor(id) {
-        super(id);
-
-        /**
-         *
-         * @type {Array<OptionGroup|Option>}
-         */
-        this.children = [];
-    }
+    children = [];
 
     /**
      *
@@ -141,6 +133,7 @@ export class OptionGroup extends OptionAbstract {
      *
      * @param {string} path
      * @param {Storage} storage
+     * @returns {Promise}
      */
     attachToStorage(path, storage) {
         const group = this;
@@ -151,20 +144,6 @@ export class OptionGroup extends OptionAbstract {
             storage.load(key, resolve, reject);
         });
 
-        p
-            .then((loaded) => {
-                try {
-                    group.fromJSON(JSON.parse(loaded));
-                } catch (e) {
-                    console.log('Failed to load options')
-                }
-            })
-            .catch(console.error)
-            .finally(() => {
-
-                group.traverseOptions(op => op.on.written.add(store));
-            });
-
 
         function store() {
             const json = group.toJSON();
@@ -174,6 +153,15 @@ export class OptionGroup extends OptionAbstract {
             storage.store(key, value, noop, console.error, noop);
         }
 
+        return p
+            .then((loaded) => {
+                group.fromJSON(JSON.parse(loaded));
+            })
+            .finally(() => {
+
+                group.traverseOptions(op => op.on.written.add(store));
+            });
+
     }
 }
 

package/src/engine/options/OptionGroup.spec.js

@@ -0,0 +1,61 @@
+import { OptionGroup } from "./OptionGroup.js";
+import { noop } from "../../core/function/Functions.js";
+import { InMemoryStorage } from "../save/storage/InMemoryStorage.js";
+
+test("constructor", () => {
+    const group = new OptionGroup("x");
+
+    expect(group.id).toEqual("x");
+});
+
+test("resolve non-existent", () => {
+
+    const group = new OptionGroup("x");
+
+    expect(() => group.resolve(['a'])).toThrow();
+
+});
+
+test("add/get", () => {
+    const group = new OptionGroup("x");
+
+    group.add("a", noop, noop, {});
+
+    expect(group.getChildById('a')).toBeDefined();
+});
+
+test("to/from JSON", () => {
+    const group = new OptionGroup("x");
+
+    const writer = jest.fn();
+
+    group.add("a", () => 7, writer, {});
+
+    const json = group.toJSON();
+
+    expect(json).toEqual({ a: 7 });
+
+    group.fromJSON({ a: 13 });
+
+    expect(writer).toHaveBeenCalledTimes(1);
+    expect(writer).toHaveBeenCalledWith(13);
+});
+
+
+test("attach to storage", async () => {
+    const group = new OptionGroup("x");
+
+    const op_a = {
+        value: 3
+    };
+
+    group.add('a', () => op_a.value, v => op_a.value = v, {});
+
+    const storage = new InMemoryStorage();
+
+    storage.store('options', JSON.stringify({ a: 13 }));
+
+    await group.attachToStorage('options', storage);
+
+    expect(op_a.value).toEqual(13);
+});

package/src/engine/save/storage/InMemoryStorage.js

@@ -1,10 +1,11 @@
 import Storage from "../Storage.js";
 import { collectIteratorValueToArray } from "../../../core/collection/collectIteratorValueToArray.js";
+import { noop } from "../../../core/function/Functions.js";
 
 export class InMemoryStorage extends Storage {
     #data = new Map();
 
-    store(key, value, resolve, reject, progress) {
+    store(key, value, resolve=noop, reject, progress) {
         this.#data.set(key, value);
 
         resolve();
@@ -14,7 +15,7 @@ export class InMemoryStorage extends Storage {
         resolve(this.#data.get(key));
     }
 
-    remove(key, resolve, reject) {
+    remove(key, resolve=noop, reject) {
         this.#data.delete(key);
 
         resolve();

package/src/engine/simulation/Ticker.js

@@ -6,32 +6,29 @@ import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
 import { assert } from "../../core/assert.js";
 
 class Ticker {
+    /**
+     * @readonly
+     * @type {Clock}
+     */
+    clock = new Clock();
+    /**
+     * @private
+     * @type {boolean}
+     */
+    isRunning = false;
+
+    /**
+     *
+     * @type {SignalHandler[]}
+     */
+    callbacks = [];
+
     /**
      *
      * @constructor
      */
     constructor() {
-
-        /**
-         * @readonly
-         * @type {Clock}
-         */
-        this.clock = new Clock();
-
-
         this.clock.pause();
-
-        /**
-         * @private
-         * @type {boolean}
-         */
-        this.isRunning = false;
-
-        /**
-         *
-         * @type {SignalHandler[]}
-         */
-        this.callbacks = [];
     }
 
     /**

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

@@ -146,12 +146,8 @@ export default SoundController;
 
 
 export class SoundControllerSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = SoundController;
-        this.version = 0;
-    }
+    klass = SoundController;
+    version = 0;
 
     /**
      *

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

@@ -42,26 +42,8 @@ export default SoundListener;
 
 
 export class SoundListenerSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
+    klass = SoundListener;
+    version = 0;
 
-        this.klass = SoundListener;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SoundListener} value
-     */
-    serialize(buffer, value) {
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SoundListener} value
-     */
-    deserialize(buffer, value) {
-    }
+    // NO-OP
 }

package/src/engine/sound/ecs/emitter/SoundEmitterSerializationAdapter.js

@@ -3,13 +3,9 @@ import { SoundEmitter } from "./SoundEmitter.js";
 import { SoundTrack } from "./SoundTrack.js";
 
 export class SoundEmitterSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = SoundEmitter;
-        this.version = 2;
-    }
 
+    klass = SoundEmitter;
+    version = 2;
 
     /**
      *

package/src/generation/GridTaskGroup.js

@@ -2,16 +2,12 @@ import TaskGroup from "../core/process/task/TaskGroup.js";
 import { GridTaskGenerator } from "./grid/GridTaskGenerator.js";
 
 export class GridTaskGroup extends GridTaskGenerator {
-    constructor() {
-        super();
 
-        /**
-         *
-         * @type {GridTaskGenerator[]}
-         */
-        this.children = [];
-
-    }
+    /**
+     *
+     * @type {GridTaskGenerator[]}
+     */
+    children = [];
 
 
     /**