@woosh/meep-engine 2.50.2 → 2.51.0

package/src/engine/graphics/three/expand_aabb_by_transformed_three_object.spec.js

@@ -0,0 +1,108 @@
+import { expand_aabb_by_transformed_three_object } from "./expand_aabb_by_transformed_three_object.js";
+import { MATRIX_4_IDENTITY } from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { BufferAttribute, BufferGeometry, Group, Mesh } from "three";
+
+/**
+ *
+ * @param {Object3D} object
+ * @return {number[]}
+ */
+function compute(object) {
+    object.updateMatrixWorld();
+
+    const result = [
+        Infinity, Infinity, Infinity,
+        -Infinity, -Infinity, -Infinity
+    ];
+
+    expand_aabb_by_transformed_three_object(result, object, MATRIX_4_IDENTITY);
+
+    return result;
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {BufferGeometry}
+ */
+function makePointGeometry(x, y, z) {
+    const geo = new BufferGeometry();
+    geo.setIndex([0, 0, 0]);
+    geo.setAttribute(
+        "position",
+        new BufferAttribute(new Float32Array([x, y, z]), 3, false)
+    );
+    return geo;
+}
+
+test("single point at depth 0", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const aabb = compute(new Mesh(geo));
+
+    expect(aabb[0]).toBeCloseTo(1);
+    expect(aabb[3]).toBeCloseTo(1);
+
+    expect(aabb[1]).toBeCloseTo(3);
+    expect(aabb[4]).toBeCloseTo(3);
+
+    expect(aabb[2]).toBeCloseTo(5);
+    expect(aabb[5]).toBeCloseTo(5);
+});
+
+test("single point at depth 1", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const object_1 = new Group();
+    const object_2 = new Mesh(geo);
+
+    object_1.add(object_2);
+    object_2.position.set(7, -11, 13);
+
+    const aabb = compute(object_1);
+
+    expect(aabb[0]).toBeCloseTo(8);
+    expect(aabb[3]).toBeCloseTo(8);
+
+    expect(aabb[1]).toBeCloseTo(-8);
+    expect(aabb[4]).toBeCloseTo(-8);
+
+    expect(aabb[2]).toBeCloseTo(18);
+    expect(aabb[5]).toBeCloseTo(18);
+});
+
+test("single point at depth 2", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const object_0 = new Group();
+    const object_1 = new Group();
+    const object_2 = new Mesh(geo);
+
+    object_0.add(object_1);
+    object_1.add(object_2);
+
+    object_1.position.set(10, 20, 30);
+    object_1.scale.set(0.1, 0.2, 0.5);
+
+    object_2.position.set(7, -17, 13);
+
+    const aabb = compute(object_0);
+
+    const x = 10 + 8 * 0.1;
+
+    expect(aabb[0]).toBeCloseTo(x);
+    expect(aabb[3]).toBeCloseTo(x);
+
+    const y = 20 - 14 * 0.2;
+    expect(aabb[1]).toBeCloseTo(y);
+    expect(aabb[4]).toBeCloseTo(y);
+
+    const z = 30 + 18 * 0.5;
+    expect(aabb[2]).toBeCloseTo(z);
+    expect(aabb[5]).toBeCloseTo(z);
+});

package/src/engine/graphics/trail/TemporalPath.js

@@ -1,124 +1,129 @@
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
 
+const TABLE_SPEC = RowFirstTableSpec.get([
+    // time
+    BinaryDataType.Float32,
+    // position XYZ
+    BinaryDataType.Float32, BinaryDataType.Float32, BinaryDataType.Float32
+]);
 
-function TemporalPath() {
+/**
+ * Keeps tracks of a moving point for a given time window
+ */
+export class TemporalPath {
     /**
      * How long to track the points for
      * @type {number}
      */
-    this.memory = 0;
+    memory = 0;
 
     /**
      *
      * @type {number}
      */
-    this.time = 0;
+    time = 0;
 
     /**
      *
      * @type {RowFirstTable}
      */
-    this.data = new RowFirstTable([
-        BinaryDataType.Float32,
-        BinaryDataType.Float32, BinaryDataType.Float32, BinaryDataType.Float32
-    ]);
-}
+    data = new RowFirstTable(TABLE_SPEC);
 
-const tempSequenceRecord = [];
+    updateSequence() {
+        const sequence = this.data;
+        //determine if position sequence can be cropped
+        const numRecords = sequence.length;
 
-TemporalPath.prototype.updateSequence = function () {
-    const sequence = this.data;
-    //determine if position sequence can be cropped
-    const numRecords = sequence.length;
+        if (numRecords === 0) {
+            return;
+        }
 
-    if (numRecords === 0) {
-        return;
-    }
+        const lastUsefulMemory = this.time - this.memory;
 
-    const lastUsefulMemory = this.time - this.memory;
+        let i = 0;
 
-    let i = 0;
+        while (i < numRecords && sequence.readCellValue(i, 0) < lastUsefulMemory) {
+            i++;
+        }
 
-    while (i < numRecords && sequence.readCellValue(i, 0) < lastUsefulMemory) {
-        i++;
+        if (i > 0) {
+            sequence.removeRows(0, i);
+        }
     }
 
-    if (i > 0) {
-        sequence.removeRows(0,i);
-    }
-};
+    /**
+     *
+     * @param {number} timeDelta
+     */
+    update(timeDelta) {
+        this.time += timeDelta;
 
-/**
- *
- * @param {number} timeDelta
- */
-TemporalPath.prototype.update = function (timeDelta) {
-    this.time += timeDelta;
+        this.updateSequence();
+    }
 
-    this.updateSequence();
-};
+    /**
+     * @returns {number}
+     */
+    computeLength() {
 
-/**
- * @returns {number}
- */
-TemporalPath.prototype.computeLength = function () {
+        let i;
+        const numRecords = this.data.length;
 
-    let i;
-    const numRecords = this.data.length;
+        if (numRecords === 0) {
+            return 0;
+        }
 
-    if (numRecords === 0) {
-        return 0;
-    }
+        let _x, _y, _z;
 
-    let _x, _y, _z;
+        this.data.getRow(0, tempSequenceRecord);
 
-    this.data.getRow(0, tempSequenceRecord);
+        _x = tempSequenceRecord[1];
+        _y = tempSequenceRecord[2];
+        _z = tempSequenceRecord[3];
 
-    _x = tempSequenceRecord[1];
-    _y = tempSequenceRecord[2];
-    _z = tempSequenceRecord[3];
 
+        let result = 0;
 
-    let result = 0;
+        for (i = 1; i < numRecords; i++) {
+            this.data.getRow(i, tempSequenceRecord);
 
-    for (i = 1; i < numRecords; i++) {
-        this.data.getRow(i, tempSequenceRecord);
+            const x = tempSequenceRecord[1];
+            const y = tempSequenceRecord[2];
+            const z = tempSequenceRecord[3];
 
-        const x = tempSequenceRecord[1];
-        const y = tempSequenceRecord[2];
-        const z = tempSequenceRecord[3];
+            const dX = x - _x;
+            const dY = y - _y;
+            const dZ = z - _z;
 
-        const dX = x - _x;
-        const dY = y - _y;
-        const dZ = z - _z;
+            const d = Math.sqrt(dX * dX + dY * dY + dZ * dZ);
 
-        const d = Math.sqrt(dX * dX + dY * dY + dZ * dZ);
+            result += d;
 
-        result += d;
+            //remember current coordinates
+            _x = x;
+            _y = y;
+            _z = z;
+        }
 
-        //remember current coordinates
-        _x = x;
-        _y = y;
-        _z = z;
+        return result;
     }
 
-    return result;
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-TemporalPath.prototype.append = function (x, y, z) {
-    tempSequenceRecord[0] = this.time;
-    tempSequenceRecord[1] = x;
-    tempSequenceRecord[2] = y;
-    tempSequenceRecord[3] = z;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    append(x, y, z) {
+        tempSequenceRecord[0] = this.time;
+        tempSequenceRecord[1] = x;
+        tempSequenceRecord[2] = y;
+        tempSequenceRecord[3] = z;
 
-    this.data.addRow(tempSequenceRecord);
-};
+        this.data.addRow(tempSequenceRecord);
+    }
+}
 
-export { TemporalPath };
+const tempSequenceRecord = [];

package/src/engine/graphics/trail/TemporalPath.spec.js

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

package/src/engine/graphics/trail/x/RibbonX.spec.js

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

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/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/engine/MeepSettings.js

@@ -1,9 +0,0 @@
-import * as settings from '../../../../../data/meep-settings.json';
-
-/**
- *
- * @type {{
- *
- * }}
- */
-export const MeepSettings = settings.default;