@woosh/meep-engine 2.50.3 → 2.52.0

package/src/engine/grid/components/GridPosition2Transform.js

@@ -1,5 +1,4 @@
 import Vector2 from "../../../core/geom/Vector2.js";
-import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { BinaryClassUpgrader } from "../../ecs/storage/binary/BinaryClassUpgrader.js";
 import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
 
@@ -116,7 +115,7 @@ export class GridPosition2Transform {
      * @returns {number}
      */
     hash() {
-        return this.offset.hashCode();
+        return this.offset.hash();
     }
 
 }
@@ -124,74 +123,6 @@ export class GridPosition2Transform {
 GridPosition2Transform.typeName = "GridPosition2Transform";
 
 
-export class GridPosition2TransformSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GridPosition2Transform;
-        this.version = 1;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridPosition2Transform} value
-     */
-    serialize(buffer, value) {
-        const offsetX = value.offset.x;
-        const offsetY = value.offset.y;
-
-        let header = 3;
-        if (offsetX === 0 && offsetY === 0) {
-            header = 0;
-        } else if (offsetX === 0) {
-            header = 2;
-        } else if (offsetY === 0) {
-            header = 1;
-        } else {
-            //both coordinates are present
-            header = 3;
-        }
-
-        buffer.writeUint8(header);
-
-        if ((header & 1) !== 0) {
-            //write X
-            buffer.writeFloat32(offsetX);
-        }
-
-        if ((header & 2) !== 0) {
-            //write Y
-            buffer.writeFloat32(offsetY);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridPosition2Transform} value
-     */
-    deserialize(buffer, value) {
-        //read header
-        const header = buffer.readUint8();
-
-
-        let offsetX = 0, offsetY = 0;
-
-        if ((header & 1) !== 0) {
-            //write X
-            offsetX = buffer.readFloat32();
-        }
-
-        if ((header & 2) !== 0) {
-            //write Y
-            offsetY = buffer.readFloat32();
-        }
-
-        value.offset.set(offsetX, offsetY);
-    }
-}
-
 export class GridPosition2TransformSerializationUpgrader_0_1 extends BinaryClassUpgrader {
     constructor() {
         super();

package/src/engine/grid/components/GridPosition2TransformSerializationAdapter.js

@@ -0,0 +1,70 @@
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { GridPosition2Transform } from "./GridPosition2Transform.js";
+
+export class GridPosition2TransformSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GridPosition2Transform;
+        this.version = 1;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridPosition2Transform} value
+     */
+    serialize(buffer, value) {
+        const offsetX = value.offset.x;
+        const offsetY = value.offset.y;
+
+        let header = 3;
+        if (offsetX === 0 && offsetY === 0) {
+            header = 0;
+        } else if (offsetX === 0) {
+            header = 2;
+        } else if (offsetY === 0) {
+            header = 1;
+        } else {
+            //both coordinates are present
+            header = 3;
+        }
+
+        buffer.writeUint8(header);
+
+        if ((header & 1) !== 0) {
+            //write X
+            buffer.writeFloat32(offsetX);
+        }
+
+        if ((header & 2) !== 0) {
+            //write Y
+            buffer.writeFloat32(offsetY);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridPosition2Transform} value
+     */
+    deserialize(buffer, value) {
+        //read header
+        const header = buffer.readUint8();
+
+
+        let offsetX = 0, offsetY = 0;
+
+        if ((header & 1) !== 0) {
+            //write X
+            offsetX = buffer.readFloat32();
+        }
+
+        if ((header & 2) !== 0) {
+            //write Y
+            offsetY = buffer.readFloat32();
+        }
+
+        value.offset.set(offsetX, offsetY);
+    }
+}

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

@@ -0,0 +1,5 @@
+import { InputDeviceSwitch } from "./InputDeviceSwitch.js";
+
+test("constructor should not throw", () => {
+    expect(() => new InputDeviceSwitch()).not.toThrow();
+});

package/src/engine/input/ecs/{InputBinding.js → components/InputBinding.js}

@@ -1,4 +1,4 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../../../core/assert.js";
 
 export class InputBinding {
     /**

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

@@ -5,7 +5,7 @@
 import List from '../../../../core/collection/list/List.js';
 import { assert } from "../../../../core/assert.js";
 import Signal from "../../../../core/events/signal/Signal.js";
-import { InputBinding } from "../InputBinding.js";
+import { InputBinding } from "./InputBinding.js";
 
 
 class InputController {
@@ -15,7 +15,7 @@ class InputController {
      * @constructor
      */
     constructor(bindings = []) {
-        assert.ok(Array.isArray(bindings), 'Expected bindings to be an array, instead got something else');
+        assert.isArray(bindings, 'bindings');
 
         this.mapping = new List();
 

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

@@ -20,8 +20,8 @@ export class InputBinding {
      * @param {string} event
      */
     set(path, event) {
-        assert.typeOf(path, 'string', path);
-        assert.typeOf(event, 'string', path);
+        assert.isString(path, "path");
+        assert.isString(event, "event");
 
         this.path = path;
         this.event = event;

package/src/engine/input/ecs/util/TerrainCameraTargetSampler.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
-import { sampler2d_scale_down_linear } from "../../../graphics/texture/sampler/sampler2d_scale_down_linear.js";
+import { sampler2d_scale_down_linear } from "../../../graphics/texture/sampler/resize/sampler2d_scale_down_linear.js";
 import { computeWholeDivisorLow } from "../../../../core/math/computeWholeDivisorLow.js";
 
 /**

package/src/engine/input/ecs/util/TopDownCameraControllerHelper.js

@@ -2,7 +2,7 @@
  * Created by Alex on 22/08/2015.
  */
 import { Transform } from '../../../ecs/transform/Transform.js';
-import Renderable from '../../../ecs/components/Renderable.js';
+import Renderable from '../../../ecs/renderable/Renderable.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
 import EntityBuilder from '../../../ecs/EntityBuilder.js';
 import { Group as ThreeGroup, Matrix4 as ThreeMatrix4, Mesh as ThreeMesh, MeshLambertMaterial } from 'three';

package/src/engine/intelligence/behavior/behavior_to_dot.spec.js

@@ -0,0 +1,25 @@
+import { behavior_to_dot } from "./behavior_to_dot.js";
+import { SucceedingBehavior } from "./primitive/SucceedingBehavior.js";
+import { SequenceBehavior } from "./composite/SequenceBehavior.js";
+import { ParallelBehavior } from "./composite/ParallelBehavior.js";
+
+test("single behavior should produce a valid string", () => {
+    const dot = behavior_to_dot(SucceedingBehavior.INSTANCE);
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});
+
+test("'sequence' should produce a valid string", () => {
+    const dot = behavior_to_dot(SequenceBehavior.from([SucceedingBehavior.INSTANCE]));
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});
+
+test("'parallel' should produce a valid string", () => {
+    const dot = behavior_to_dot(ParallelBehavior.from([SucceedingBehavior.INSTANCE]));
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});

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

@@ -45,9 +45,9 @@ export class DelayBehavior extends Behavior {
      * @return {DelayBehavior}
      */
     static from(value) {
-        assert.isNumber(value,  'value');
-        assert.notNaN(value,'value');
-        assert.isFiniteNumber(value,'value');
+        assert.isNumber(value, 'value');
+        assert.notNaN(value, 'value');
+        assert.isFiniteNumber(value, 'value');
 
         const r = new DelayBehavior();
 
@@ -56,7 +56,9 @@ export class DelayBehavior extends Behavior {
         return r;
     }
 
-    initialize() {
+    initialize(ctx) {
+        super.initialize(ctx);
+
         this.elapsed = 0;
     }
 

package/src/engine/intelligence/blackboard/Blackboard.d.ts

@@ -1,6 +1,8 @@
 import {AbstractBlackboard} from "./AbstractBlackboard";
 
 export class Blackboard extends AbstractBlackboard {
+    copy(other: Blackboard): void
+
     toJSON(): { [key: string]: (number | boolean | string) }
 
     fromJSON(json: any): void

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

@@ -164,14 +164,48 @@ export class Blackboard extends AbstractBlackboard {
 
     /**
      *
+     * NOTE: where variables of same type with same names exist - they are kept and their values are updated
      * @param {Blackboard} other
      */
     copy(other) {
-        this.reset();
+        // perform coalescence
+
+        const this_data = this.data;
 
         other.traverse((name, value, type) => {
-            this.acquire(name, type, value.getValue());
+
+            const variable = this_data[name];
+
+            const other_value = value.getValue();
+
+            if (variable === undefined) {
+                this.acquire(name, type, other_value);
+            } else if (variable.type !== type) {
+                // type mismatch
+                delete this_data[name]
+                this.acquire(name, type, other_value);
+            } else {
+                // variable exists and types match
+                variable.value.set(other_value);
+            }
+
         });
+
+        // find out which keys should be removed
+        const garbage = [];
+
+        for (const dataKey in this_data) {
+            const variable = this_data[dataKey];
+            if (!other.contains(dataKey, variable.type)) {
+                garbage.push(dataKey);
+            }
+        }
+
+        for (let i = 0; i < garbage.length; i++) {
+            const key = garbage[i];
+
+            delete this_data[key];
+        }
     }
 
     /**

package/src/engine/intelligence/blackboard/Blackboard.spec.js

@@ -39,6 +39,41 @@ test("entry is copied across when blackboard is copied", () => {
     expect(b.acquireNumber('test').getValue()).toBe(7);
 });
 
+test('copy when destination has a variable with the same name but a different type', () => {
+
+    const a = new Blackboard();
+
+    a.acquireNumber('test', 7);
+
+
+    const b = new Blackboard();
+
+    b.acquireBoolean("test", true);
+
+    b.copy(a);
+
+    expect(b.acquireNumber('test').getValue()).toEqual(7);
+});
+
+test("copy preserves existing references and updates their value", () => {
+
+    const a = new Blackboard();
+
+    a.acquireNumber('test', 7);
+
+    const b = new Blackboard();
+
+    const vector_before = b.acquireNumber("test", 3);
+
+    b.copy(a);
+
+    const vector_after = b.acquireNumber("test");
+
+    expect(vector_after).toBe(vector_before);
+    expect(vector_after.getValue()).toBe(7);
+
+});
+
 test("to/from JSON serialization consistency", () => {
 
     const source = new Blackboard();
@@ -60,3 +95,17 @@ test("to/from JSON serialization consistency", () => {
     expect(target.contains('label', DataType.String)).toBe(true);
     expect(target.acquireString('label').getValue()).toBe('hello');
 });
+
+test("increment number", () => {
+    const bb = new Blackboard();
+
+    bb.acquireNumber("x", 3);
+
+    bb.incrementNumber("x", 5);
+
+    expect(bb.acquireNumber('x').getValue()).toEqual(8);
+
+    bb.incrementNumber("x");
+
+    expect(bb.acquireNumber('x').getValue()).toEqual(9);
+});

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

@@ -9,6 +9,7 @@ test('to/from binary buffer serialization', () => {
 
     bb.acquireBoolean('a.true').set(true);
     bb.acquireBoolean('a.false').set(false);
+    bb.acquireString('x').set("test string");
 
     const buffer = new BinaryBuffer();
 
@@ -25,4 +26,5 @@ test('to/from binary buffer serialization', () => {
     expect(ba.acquireNumber('a/b/c').getValue()).toBe(42.3);
     expect(ba.acquireBoolean('a.true').getValue()).toBe(true);
     expect(ba.acquireBoolean('a.false').getValue()).toBe(false);
+    expect(ba.acquireString('x').getValue()).toBe("test string");
 });

package/src/engine/navigation/grid/{AStar.js → find_path_on_grid_astar.js}

@@ -42,32 +42,35 @@ function computeOrthogonalNeighbors(result, index, width, height) {
 
 /**
  *
- * @param {number|Uint8Array|Uint16Array|Float32Array} field
- * @param {Number} width
- * @param {Number} height
+ * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
+ * @param {number} width
+ * @param {number} height
  * @param {number} start
  * @param {number} goal
- * @param {Number} crossingPenalty
- * @param {Number} bendPenalty
+ * @param {number} crossingPenalty
+ * @param {number} bendPenalty
  * @param {number} blockValue
- * @returns {Array.<Number>} array of indices representing path from start to end
+ * @returns {Array.<number>} array of indices representing path from start to end
  */
-export function gridAStarSearch(field, width, height, start, goal, crossingPenalty, bendPenalty, blockValue) {
-    assert.notEqual(field, undefined, 'field is undefined');
-    assert.notEqual(field, null, 'field is null');
+export function find_path_on_grid_astar(
+    field,
+    width, height,
+    start, goal,
+    crossingPenalty,
+    bendPenalty,
+    blockValue
+) {
 
-    assert.notEqual(start, undefined, 'start is undefined');
-    assert.notEqual(start, null, 'start is null');
+    assert.defined(field, 'field');
+    assert.notNull(field, 'field');
 
-    assert.notEqual(goal, undefined, 'end is undefined');
-    assert.notEqual(goal, null, 'end is null');
 
-    assert.typeOf(start, 'number', "start");
-    assert.typeOf(goal, 'number', "goal");
+    assert.isNonNegativeInteger(start, "start");
+    assert.isNonNegativeInteger(goal, "goal");
 
-    assert.typeOf(crossingPenalty, 'number', 'crossingPenalty');
-    assert.typeOf(bendPenalty, 'number', 'bendPenalty');
-    assert.typeOf(blockValue, 'number', 'blockValue');
+    assert.isNumber(crossingPenalty, 'crossingPenalty');
+    assert.isNumber(bendPenalty, 'bendPenalty');
+    assert.isNumber(blockValue, 'blockValue');
 
 
     let limitCycles = 5000000;

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

@@ -0,0 +1,7 @@
+import { find_path_on_grid_astar } from "./find_path_on_grid_astar.js";
+
+test("sanity check on 1x1 grid", () => {
+    const path = find_path_on_grid_astar([0], 1, 1, 0, 0, 0, 0, 1);
+
+    expect(path).toEqual([0]);
+});

package/src/engine/plugin/EnginePlugin.js

@@ -2,22 +2,20 @@ import { BaseProcess } from "../../core/process/BaseProcess.js";
 import { assert } from "../../core/assert.js";
 
 export class EnginePlugin extends BaseProcess {
-    constructor() {
-        super();
 
-        /**
-         *
-         * @type {Class<EnginePlugin>[]}
-         * @private
-         */
-        this.__dependencies = [];
+    /**
+     *
+     * @type {Class<EnginePlugin>[]}
+     * @private
+     */
+    __dependencies = [];
+
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine = null;
 
-        /**
-         *
-         * @type {Engine|null}
-         */
-        this.engine = null;
-    }
 
     attach() {
         /**

package/src/engine/plugin/EnginePlugin.spec.js

@@ -0,0 +1,5 @@
+import { EnginePlugin } from "./EnginePlugin.js";
+
+test("constructor does not throw", () => {
+    new EnginePlugin();
+});

package/src/engine/plugin/EnginePluginManager.js

@@ -6,29 +6,25 @@ import { isSubclassOf } from "./isSubclassOf.js";
 import { assert } from "../../core/assert.js";
 
 export class EnginePluginManager extends BaseProcess {
-    constructor() {
-        super();
-
-        /**
-         * @private
-         * @type {Map<Class, PluginReferenceContext>}
-         */
-        this.__plugins = new Map();
-
-        /**
-         *
-         * @type {Engine}
-         */
-        this.engine = null;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__version = 0;
-    }
 
+    /**
+     * @private
+     * @type {Map<Class, PluginReferenceContext>}
+     */
+    __plugins = new Map();
+
+    /**
+     *
+     * @type {Engine}
+     */
+    engine = null;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __version = 0;
 
     /**
      *

package/src/engine/scene/transitionToScene.js

@@ -9,6 +9,7 @@ import { TaskLoadingScreen } from "../../view/task/TaskLoadingScreen.js";
 import { actionTask } from "../../core/process/task/util/actionTask.js";
 import { delayTask } from "../../core/process/task/util/delayTask.js";
 import { wrapTaskIgnoreFailure } from "../../core/process/task/util/wrapTaskIgnoreFailure.js";
+import { assert } from "../../core/assert.js";
 
 
 /**
@@ -19,7 +20,17 @@ import { wrapTaskIgnoreFailure } from "../../core/process/task/util/wrapTaskIgno
  * @param {string} [name]
  * @return {Promise}
  */
-export function transitionToScene({ tasks = [], scene, engine, name }) {
+export function transitionToScene({
+                                      tasks = [],
+                                      scene,
+                                      engine,
+                                      name
+                                  }) {
+
+    assert.defined(engine, 'engine');
+    assert.defined(scene, 'scene');
+    assert.isArray(tasks, 'tasks');
+
     if (name === undefined) {
         if (tasks.length > 0) {
             //assume name of the first task

package/src/engine/simulation/Ticker.js

@@ -51,7 +51,7 @@ class Ticker {
      * @param {*} [thisArg]
      */
     unsubscribe(callback, thisArg) {
-        assert.typeOf(callback, 'function', 'callback');
+        assert.isFunction(callback, 'callback');
 
         const callbacks = this.callbacks;
         const n = callbacks.length;

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

@@ -6,7 +6,7 @@
 import { System } from '../../ecs/System.js';
 import SoundListener from './SoundListener.js';
 import { Transform } from '../../ecs/transform/Transform.js';
-import { browserInfo } from "../../Platform.js";
+import { browserInfo } from "../../browserInfo.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { noop } from "../../../core/function/Functions.js";
 import { assert } from "../../../core/assert.js";

package/src/generation/markers/debug/visualizeMarkers.js

@@ -9,7 +9,7 @@ import {
     TetrahedronBufferGeometry
 } from "three";
 import EntityBuilder from "../../../engine/ecs/EntityBuilder.js";
-import Renderable from "../../../engine/ecs/components/Renderable.js";
+import Renderable from "../../../engine/ecs/renderable/Renderable.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import LabelView from "../../../view/common/LabelView.js";
 import GUIElement from "../../../engine/ecs/gui/GUIElement.js";

package/src/generation/theme/TerrainLayerDescription.js

@@ -17,7 +17,7 @@ export class TerrainLayerDescription {
     }
 
     hash() {
-        return computeStringHash(this.diffuse) ^ this.size.hashCode();
+        return computeStringHash(this.diffuse) ^ this.size.hash();
     }
 
     /**

package/src/view/common/LabelView.js

@@ -3,7 +3,6 @@
  * @copyright Alex Goldring 2016
  */
 import View from "../View.js";
-import { prettyPrint } from "../../core/NumberFormat.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import LinearValue from "../../core/model/LinearValue.js";
@@ -17,6 +16,7 @@ import { assert } from "../../core/assert.js";
 import ObservedInteger from "../../core/model/ObservedInteger.js";
 import { noop } from "../../core/function/Functions.js";
 import { isTypedArray } from "../../core/collection/array/typed/isTypedArray.js";
+import { number_pretty_print } from "../../core/primitives/numbers/number_pretty_print.js";
 
 
 /**
@@ -26,7 +26,7 @@ import { isTypedArray } from "../../core/collection/array/typed/isTypedArray.js"
  */
 function format(value) {
     if (typeof value === 'number') {
-        return prettyPrint(value);
+        return number_pretty_print(value);
     } else {
         return value;
     }
@@ -38,7 +38,7 @@ function format(value) {
  * @returns {string|number}
  */
 function formatNumber(v) {
-    return prettyPrint(v);
+    return number_pretty_print(v);
 }
 
 function formatArray(arr) {