@woosh/meep-engine 2.49.2 → 2.49.3

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.49.2",
+  "version": "2.49.3",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/binary/IndexedBinaryBVH.spec.js

@@ -5,3 +5,23 @@ test("constructor does not throw", () => {
 });
 
 
+test("build a tree with a single leaf", () => {
+    const bvh = new IndexedBinaryBVH();
+
+    bvh.initialize(1);
+    bvh.writeLeaf(0, -1, -3, -7, 11, 13, 17);
+
+    bvh.unsortedBuiltIntermediate();
+
+    expect(bvh.leafNodeCount).toBe(1);
+    expect(bvh.binaryNodeCount).toBe(0);
+
+    expect(bvh.x0).toBe(-1);
+    expect(bvh.y0).toBe(-3);
+    expect(bvh.z0).toBe(-7);
+
+    expect(bvh.x1).toBe(11);
+    expect(bvh.y1).toBe(13);
+    expect(bvh.z1).toBe(17);
+
+});

package/src/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.d.ts

@@ -13,6 +13,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     collect_nodes_all(destination: ArrayLike<number>, destination_offset: number): void
 
+    node_set_aabb_primitive(node_id: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
+
     node_set_aabb(node: number, aabb: ArrayLike<number>): void
 
     node_get_aabb(node: number, aabb: ArrayLike<number>): void
@@ -37,6 +39,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     node_get_height(node: number): number
 
+    swap_nodes(node_a_id: number, node_b_id: number): boolean
+
     release_all(): void
 
     trim(): void

package/src/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.spec.js

@@ -218,3 +218,33 @@ test("node property setters/getters", () => {
 
     expect(actual_aabb).toEqual(Array.from(expected_aabb));
 });
+
+
+test("node_set_aabb_primitive", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_aabb_primitive(node, -1, -3, -5, 7, 11, 13);
+
+    const aabb = [];
+
+    bvh.node_get_aabb(node, aabb);
+
+    expect(aabb).toEqual([-1, -3, -5, 7, 11, 13]);
+});
+
+test("swap two detached nodes", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+    const b = bvh.allocate_node();
+
+    bvh.node_set_user_data(a, 7);
+    bvh.node_set_user_data(b, 11);
+
+    bvh.swap_nodes(a, b);
+
+    expect(bvh.node_get_user_data(a)).toBe(11);
+    expect(bvh.node_get_user_data(b)).toBe(7);
+});

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -8,7 +8,12 @@ import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_
  * @param {number[]|Float32Array} positions_array
  * @param {number} [batch_size] can batch triangles in groups of up-to this many triangles per BVH leaf
  */
-export function ebvh_build_for_geometry_incremental(bvh, index_array, positions_array, batch_size = 1) {
+export function ebvh_build_for_geometry_incremental(
+    bvh,
+    index_array, positions_array,
+    batch_size = 1
+) {
+
     bvh.release_all();
     const triangle_count = index_array.length / 3;
 

package/src/core/bvh2/bvh3/query/bvh_collect_user_data.js

@@ -11,8 +11,12 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {number} destination_offset
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number} node
+ * @returns {number} number of collected elements
  */
-export function bvh_collect_user_data(destination, destination_offset, bvh, node) {
+export function bvh_collect_user_data(
+    destination, destination_offset,
+    bvh, node
+) {
 
     if (node === NULL_NODE) {
         return 0;

package/src/core/cache/Cache.d.ts

@@ -33,6 +33,8 @@ export class Cache<K, V> {
 
     remove(k: K): boolean
 
+    evictOne(): boolean
+
     clear(): void
 
     drop(): void

package/src/core/cache/Cache.js

@@ -18,7 +18,7 @@ export class Cache {
      * @param {function(value:Value):number} [valueWeigher= value=>1]
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
-     * @param {number} capacity initial capacity for the cache, helps prevent early resizing
+     * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
      * @constructor
      */
     constructor({

package/src/core/cache/Cache.spec.js

@@ -18,6 +18,19 @@ test("elements beyond capacity are evicted", () => {
 
 });
 
+test("trying to insert an element into the cache that's larger than the cache capacity should result in the item not being inserted", () => {
+    const cache = new Cache({
+        maxWeight: 1,
+        keyWeigher(key) {
+            return key;
+        }
+    });
+
+    cache.put(2, "hello");
+
+    expect(cache.contains(2)).toBe(false);
+});
+
 test("removeListener is called when element is evicted", () => {
 
     const removeListener = jest.fn();
@@ -140,3 +153,9 @@ test("clear with a single entry", () => {
     expect(cache.contains("x")).toBe(false);
 
 });
+
+test("calling 'evictOne' on empty cache should return false", () => {
+    const cache = new Cache();
+
+    expect(cache.evictOne()).toBe(false);
+});

package/src/core/codegen/LineBuilder.js

@@ -39,6 +39,14 @@ class LineBuilder {
      */
     indentSpaces = DEFAULT_INDENT_SPACES;
 
+    /**
+     * Number of lines
+     * @return {number}
+     */
+    get count() {
+        return this.lines.length;
+    }
+
     /**
      *
      * @return {boolean}
@@ -115,7 +123,6 @@ class LineBuilder {
     clear() {
         this.lines = [];
         this.indentation = 0;
-        this.indentSpaces = DEFAULT_INDENT_SPACES;
     }
 
     /**

package/src/core/codegen/LineBuilder.spec.js

@@ -5,3 +5,37 @@ test("Empty builder should produce empty string", () => {
 
     expect(b.build()).toEqual("");
 });
+
+test("build simple indented fragment", () => {
+    const b = new LineBuilder();
+
+    b.indentSpaces = 1;
+
+    b.add('a');
+    b.indent();
+    b.add('b');
+    b.dedent();
+    b.add('c');
+
+    expect(b.build()).toEqual('a\n b\nc');
+});
+
+test("adding another line builder copies lines correctly", () => {
+    const a = new LineBuilder();
+
+    const b = new LineBuilder();
+
+    b.add('a');
+
+    a.addLines(b);
+
+    expect(a.build()).toEqual('a');
+});
+
+test("fromText parses correct number of lines", () => {
+
+    const builder = LineBuilder.fromText('a\nb');
+
+    expect(builder.count).toBe(2);
+
+});

package/src/core/collection/array/arrayQuickSort.js

@@ -12,7 +12,12 @@ const stack = [];
  * @param {function(T[],number, number):*} [swap_operator]
  * @param {*} [swap_context]
  */
-export function arrayQuickSort(data, score_function, score_function_context, start, end, swap_operator = arraySwapElements, swap_context = undefined) {
+export function arrayQuickSort(
+    data,
+    score_function, score_function_context,
+    start, end,
+    swap_operator = arraySwapElements, swap_context = undefined
+) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -79,7 +84,11 @@ export function arrayQuickSort(data, score_function, score_function_context, sta
  * @param {number} start
  * @param {number} end
  */
-export function array_quick_sort_by_comparator(data, compare_function, compare_function_context, start, end) {
+export function array_quick_sort_by_comparator(
+    data,
+    compare_function, compare_function_context,
+    start, end
+) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;

package/src/core/collection/array/array_contains_duplicates.js

@@ -5,7 +5,12 @@
  * @param {number} [end_index] last index to be included in the search
  * @return {boolean}
  */
-export function array_contains_duplicates(source, start_index = 0, end_index = source.length - 1) {
+export function array_contains_duplicates(
+    source,
+    start_index = 0,
+    end_index = source.length - 1
+) {
+
     for (let k = start_index; k <= end_index; k++) {
 
         const element = source[k];

package/src/core/collection/array/typed/is_typed_array_equals.js

@@ -3,11 +3,16 @@ import { isArrayEqualStrict } from "../isArrayEqualStrict.js";
 
 /**
  *
- * @param {Uint8Array} a
- * @param {Uint8Array} b
+ * @param {Uint8Array|Uint32Array} a
+ * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}
  */
 export function is_typed_array_equals(a, b) {
+    if (a === b) {
+        // quick shortcut
+        return true;
+    }
+
     const a_length = a.length;
     const b_length = b.length;
 
@@ -26,13 +31,15 @@ export function is_typed_array_equals(a, b) {
         return false;
     }
 
-    const bytes_per_element = a.constructor.BYTES_PER_ELEMENT;
+    const a_constructor = a.constructor;
+    const b_constructor = b.constructor;
 
-    if (bytes_per_element !== b.constructor.BYTES_PER_ELEMENT) {
+    if (a_constructor !== b_constructor) {
         // incompatible constructors
         return false;
     }
 
+
     const a_buffer = a.buffer;
     const b_buffer = b.buffer;
 
@@ -45,6 +52,8 @@ export function is_typed_array_equals(a, b) {
     let a_proxy = a;
     let b_proxy = b;
 
+    const bytes_per_element = a_constructor.BYTES_PER_ELEMENT;
+
     if (bytes_per_element < 4 && byte_length % 4 === 0) {
         // 4 byte alignment, can use uint32
         a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);

package/src/core/collection/array/typed/is_typed_array_equals.spec.js

@@ -0,0 +1,71 @@
+import { is_typed_array_equals } from "./is_typed_array_equals.js";
+
+test("small uint32 arrays", () => {
+    expect(is_typed_array_equals(
+        new Uint32Array(0),
+        new Uint32Array(0)
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3, 5]),
+        new Uint32Array([1, 3, 5])
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([7, 3]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([7, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 7]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([1, 7])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([1, 3, 7])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3, 7]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+});
+
+test("large uin32 array", () => {
+    expect(is_typed_array_equals(
+        new Uint32Array(1024),
+        new Uint32Array(1024),
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array(1024),
+        new Uint32Array(1023),
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array(1023),
+        new Uint32Array(1024),
+    )).toBe(false);
+
+    const a = new Uint32Array(1024);
+    const b = new Uint32Array(1024);
+
+    a[127] = 1;
+
+    expect(is_typed_array_equals(
+        a,
+        b,
+    )).toBe(false);
+});

package/src/core/collection/table/RowFirstTable.js

@@ -98,7 +98,7 @@ RowFirstTable.prototype.hash = function () {
 
     const byteLength = this.data.byteLength;
 
-    const tap_count = 32;
+    const tap_count = 31;
 
     const step_size = max2(
         Math.floor(byteLength / (tap_count * 4)),

package/src/core/collection/table/RowFirstTable.spec.js

@@ -285,3 +285,39 @@ test('reverse_rows empty', () => {
 
     expect(a.length).toBe(0);
 });
+
+test("hash on an empty ", () => {
+    const table = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+
+    expect(() => table.hash()).not.toThrow();
+    expect(table.hash()).toEqual(table.hash());
+    expect(typeof table.hash() === "number").toBe(true);
+    expect(Number.isInteger(table.hash())).toBe(true);
+});
+
+test("equals method", () => {
+    const a = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+    const b = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+
+    expect(a.equals(b)).toBe(true);
+
+    a.addRow([1]);
+
+    expect(a.equals(b)).toBe(false);
+    expect(b.equals(a)).toBe(false);
+
+    b.addRow([3]);
+
+    expect(a.equals(b)).toBe(false);
+});
+
+test("toRowArray", () => {
+    const a = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8, BinaryDataType.Float64]));
+    a.addRow([3, 7.11]);
+    a.addRow([5, 13.17]);
+
+    expect(a.toRowArray()).toEqual([
+        [3, 7.11],
+        [5, 13.17],
+    ]);
+});

package/src/core/collection/table/RowFirstTableSpec.js

@@ -9,6 +9,7 @@ import { computeStringHash } from "../../primitives/strings/computeStringHash.js
 import { isArrayEqualStrict } from "../array/isArrayEqualStrict.js";
 import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
 import { DataTypeByteSizes } from "../../binary/type/DataTypeByteSizes.js";
+import { assert } from "../../assert.js";
 
 /**
  * @readonly
@@ -158,6 +159,8 @@ function genCellReader(type, offset, endianType = EndianType.BigEndian) {
  * @constructor
  */
 export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
+    assert.isArray(types, 'types');
+
     const numTypes = types.length;
 
     /**

package/src/core/color/hsv2rgb.js

@@ -10,22 +10,27 @@ import { float2uint8 } from "../binary/float2uint8.js";
  */
 export function hsv2rgb(h, s, v) {
 
-    let _h = h % 1;
+    let _h = h;
 
     if (_h < 0) {
-        _h = h + 1;
+        _h = _h + Math.ceil(Math.abs(_h));
     }
 
+    _h = _h % 1;
+
     const _s = clamp01(s);
     const _v = clamp01(v);
 
     let r, g, b, i, f, p, q, t;
 
-    i = Math.floor(h * 6);
+    i = Math.floor(_h * 6);
+
     f = _h * 6 - i;
+
     p = _v * (1 - _s);
     q = _v * (1 - f * _s);
     t = _v * (1 - (1 - f) * _s);
+
     switch (i % 6) {
         case 0:
             r = _v, g = t, b = p;

package/src/core/color/hsv2rgb.spec.js

@@ -0,0 +1,43 @@
+import { hsv2rgb } from "./hsv2rgb.js";
+
+function validate_element(number) {
+    expect(typeof number).toBe('number');
+    expect(Number.isNaN(number)).toBe(false);
+
+    expect(number).toBeLessThanOrEqual(255);
+    expect(number).toBeGreaterThanOrEqual(0);
+}
+
+function validate_rgb(rgb) {
+    expect(rgb).not.toBeUndefined();
+    expect(rgb).not.toBeNull();
+    expect(typeof rgb).toBe('object');
+
+    validate_element(rgb.r);
+    validate_element(rgb.g);
+    validate_element(rgb.b);
+}
+
+test("sanity test", () => {
+
+    validate_rgb(hsv2rgb(0, 0, 0));
+    validate_rgb(hsv2rgb(0, 0, 1));
+    validate_rgb(hsv2rgb(0, 1, 0));
+    validate_rgb(hsv2rgb(0, 1, 1));
+    validate_rgb(hsv2rgb(1, 0, 0));
+    validate_rgb(hsv2rgb(1, 0, 1));
+    validate_rgb(hsv2rgb(1, 1, 0));
+    validate_rgb(hsv2rgb(1, 1, 1));
+
+    validate_rgb(hsv2rgb(0.5, 0.5, 0.5));
+
+    validate_rgb(hsv2rgb(0.1, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.2, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.3, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.4, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.6, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.7, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.8, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.9, 0.5, 0.5));
+
+});

package/src/core/geom/3d/aabb/aabb3_array_intersects_ray_array.js

@@ -7,7 +7,8 @@ import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
  * @returns {boolean}
  */
 export function aabb3_array_intersects_ray_array(aabb, ray) {
-    return aabb3_intersects_ray(aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
+    return aabb3_intersects_ray(
+        aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
         ray[0], ray[1], ray[2],
         ray[3], ray[4], ray[5]
     );

package/src/core/graph/SquareMatrix.js

@@ -53,15 +53,7 @@ export class SquareMatrix {
      * @param {SquareMatrix} other
      */
     subtract(other) {
-        const size = this.size;
-        const data_length = size * size;
-
-        const this_data = this.data;
-        const other_data = other.data;
-
-        for (let i = 0; i < data_length; i++) {
-            this_data[i] -= other_data[i];
-        }
+        this.subtractMatrices(this,other);
     }
 
     /**

package/src/core/{land → lang}/reactive/compileReactiveExpression.spec.js

@@ -9,11 +9,11 @@ import { ReactiveGreaterThanOrEqual } from "../../model/reactive/model/comparati
 import { ReactiveLessThan } from "../../model/reactive/model/comparative/ReactiveLessThan.js";
 import { ReactiveLessThanOrEqual } from "../../model/reactive/model/comparative/ReactiveLessThanOrEqual.js";
 import { ReactiveNotEquals } from "../../model/reactive/model/comparative/ReactiveNotEquals.js";
-import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.d.ts";
+import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.js";
 import { ReactiveNot } from "../../model/reactive/model/logic/ReactiveNot.js";
 import { ReactiveOr } from "../../model/reactive/model/logic/ReactiveOr.js";
 import { ReactiveLiteralNumber } from "../../model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.d.ts";
+import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.js";
 import { compileReactiveExpression } from "./compileReactiveExpression.js";
 
 test('compile: REFERENCE', () => {

package/src/core/model/reactive/trigger/ReactiveTrigger.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { compileReactiveExpression } from "../../../land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../lang/reactive/compileReactiveExpression.js";
 import DataType from "../../../parser/simple/DataType.js";
 import { inferReactiveExpressionTypes } from "../transform/ReactiveTypeInferrence.js";
 

package/src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.js

@@ -2,7 +2,7 @@ import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { assert } from "../../../../../core/assert.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { Transform } from "../../../transform/Transform.js";
-import { compileReactiveExpression } from "../../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 
 export class SendRequestActionDescription extends AbstractActionDescription {
     constructor() {

package/src/engine/ecs/dynamic_actions/actions/definition/WhiteToBlackboardActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { Blackboard } from "../../../../intelligence/blackboard/Blackboard.js";
-import { compileReactiveExpression } from "../../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 import { assert } from "../../../../../core/assert.js";
 
 export class WhiteToBlackboardActionDescription extends AbstractActionDescription {

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js

@@ -2,7 +2,7 @@ import UUID from "../../../../core/UUID.js";
 import { assert } from "../../../../core/assert.js";
 import { inferReactiveExpressionTypes } from "../../../../core/model/reactive/transform/ReactiveTypeInferrence.js";
 import DataType from "../../../../core/parser/simple/DataType.js";
-import { compileReactiveExpression } from "../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../core/lang/reactive/compileReactiveExpression.js";
 import { deserializeActionFromJSON } from "../actions/definition/deserializeActionFromJSON.js";
 import { DynamicRuleCooldownDescription } from "./DynamicRuleCooldownDescription.js";
 

package/src/engine/ecs/fow/FogOfWarRevealer.js

@@ -1,5 +1,4 @@
 import Vector1 from "../../../core/geom/Vector1.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 
 export class FogOfWarRevealer {
     constructor() {
@@ -28,29 +27,3 @@ export class FogOfWarRevealer {
 FogOfWarRevealer.typeName = 'FogOfWarRevealer';
 
 
-export class FogOfWarRevealerSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = FogOfWarRevealer;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {FogOfWarRevealer} value
-     */
-    serialize(buffer, value) {
-        value.radius.toBinaryBuffer(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {FogOfWarRevealer} value
-     */
-    deserialize(buffer, value) {
-        value.radius.fromBinaryBuffer(buffer);
-    }
-}

package/src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.js

@@ -0,0 +1,29 @@
+import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
+import { FogOfWarRevealer } from "../FogOfWarRevealer.js";
+
+export class FogOfWarRevealerSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = FogOfWarRevealer;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {FogOfWarRevealer} value
+     */
+    serialize(buffer, value) {
+        value.radius.toBinaryBuffer(buffer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {FogOfWarRevealer} value
+     */
+    deserialize(buffer, value) {
+        value.radius.fromBinaryBuffer(buffer);
+    }
+}

package/src/engine/ecs/transform/TransformSerializationAdapter.spec.js

@@ -0,0 +1,28 @@
+import { TransformSerializationAdapter } from "./TransformSerializationAdapter.js";
+import { Transform } from "./Transform.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+test("to/from consistency", () => {
+    const adapter = new TransformSerializationAdapter();
+
+    const expected = new Transform();
+    expected.position.set(1, 3, -7.3);
+    expected.scale.set(-5, 7, -13.8);
+    expected.rotation.set(17, -27, 31, 37);
+
+    expected.rotation.normalize();
+
+    const buffer = new BinaryBuffer();
+
+    adapter.serialize(buffer, expected);
+
+    buffer.position = 0;
+
+    const actual = new Transform();
+
+    adapter.deserialize(buffer, actual);
+
+    expect(actual.position.roughlyEquals(expected.position)).toBe(true);
+    expect(actual.scale.roughlyEquals(expected.scale)).toBe(true);
+    expect(actual.rotation.roughlyEquals(expected.rotation, 0.001)).toBe(true);
+});

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

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

package/src/engine/options/Option.js

@@ -1,8 +1,16 @@
 import { noop } from "../../core/function/Functions.js";
 import Signal from "../../core/events/signal/Signal.js";
 import { OptionAbstract } from "./OptionAbstract.js";
+import { assert } from "../../core/assert.js";
 
 export class Option extends OptionAbstract {
+
+    on = {
+        written: new Signal(),
+        writeFailed: new Signal(),
+        settingsUpdated: new Signal()
+    };
+
     /**
      *
      * @param {string} id
@@ -16,18 +24,32 @@ export class Option extends OptionAbstract {
     }) {
         super(id);
 
+        assert.isFunction(read, 'read');
+
         const self = this;
 
         function wrappedWrite(v) {
-            const result = write(v);
-
-            if (result !== undefined && typeof result.then === "function") {
-                result.then(
-                    () => self.on.written.dispatch(v),
-                    (e) => self.on.writeFailed.dispatch(v, e)
-                );
-            } else {
-                self.on.written.dispatch(v);
+            let result;
+
+            let exception_thrown = false;
+
+            try {
+                result = write(v);
+            } catch (e) {
+                exception_thrown = true;
+
+                self.on.writeFailed.send2(v, e);
+            }
+
+            if (!exception_thrown) {
+                if (result !== undefined && typeof result.then === "function") {
+                    result.then(
+                        () => self.on.written.send1(v),
+                        (e) => self.on.writeFailed.send2(v, e)
+                    );
+                } else {
+                    self.on.written.send1(v);
+                }
             }
 
             return result;
@@ -43,13 +65,13 @@ export class Option extends OptionAbstract {
          */
         this.isTransient = (settings.transient === true);
 
-        this.on = {
-            written: new Signal(),
-            writeFailed: new Signal(),
-            settingsUpdated: new Signal()
-        };
     }
 
+    /**
+     *
+     * @param {string} key
+     * @param {number|boolean|string} value
+     */
     setSetting(key, value) {
         this.settings[key] = value;
 

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

@@ -0,0 +1,69 @@
+import { Option } from "./Option.js";
+import { returnOne } from "../../core/function/Functions.js";
+
+test("constructing a simple valid option", () => {
+    const option = new Option("x", returnOne);
+
+    expect(option.id).toEqual('x');
+});
+
+test("'written' signal is invoked after write succeeds", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    const callback = jest.fn();
+
+    opt.on.written.add(callback);
+
+    opt.write(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+});
+
+test("'writeFailed' signal is invoked after write throws", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    const callback = jest.fn();
+
+    opt.on.written.add(callback);
+
+    opt.write(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+});
+
+test("toJSON", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    expect(opt.toJSON()).toBe(13);
+
+});
+
+test("fromJSON", () => {
+
+    let value = 1;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    opt.fromJSON(17);
+
+    expect(value).toBe(17);
+
+
+});
+
+test("computePath on a detached option should be just the ID of that option", () => {
+    const op = new Option("x", returnOne);
+
+    expect(op.computePath()).toEqual(["x"]);
+});
+

package/src/engine/reference/v2/Reference.d.ts

@@ -3,6 +3,8 @@ import Signal from "../../../core/events/signal/Signal";
 export class Reference<T> {
     readonly onReleased: Signal<Reference<T>, T>
 
+    readonly bound: boolean
+
     getValue(): T | null
 
     release(): void

package/src/engine/reference/v2/Reference.js

@@ -27,6 +27,9 @@ export class Reference {
      */
     #is_bound = false;
 
+    get bound(){
+        return this.#is_bound;
+    }
 
     /**
      *

package/src/engine/reference/v2/Reference.spec.js

@@ -0,0 +1,44 @@
+import { Reference } from "./Reference.js";
+
+test("constructor does not throw", () => {
+    expect(() => new Reference()).not.toThrow();
+});
+
+test("newly created reference is unbound", () => {
+
+    const ref = new Reference();
+
+    expect(ref.bound).toBe(false);
+
+});
+
+test("bind sets value", () => {
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    expect(ref.getValue()).toBe(7);
+    expect(ref.bound).toBe(true);
+});
+
+test("re-binding a live reference throws an exception", () => {
+
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    expect(() => ref.bind(13)).toThrow();
+
+});
+
+test("release resets reference", () => {
+
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    ref.release();
+
+    expect(ref.getValue()).toBeNull();
+    expect(ref.bound).toBe(false);
+});

package/src/core/bvh2/bvh3/BVHNodeProxy.js

@@ -1,53 +0,0 @@
-export class BVHNodeProxy {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node = -1;
-
-        /**
-         *
-         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
-         * @private
-         */
-        this.__tree = null;
-    }
-
-    /**
-     *
-     * @param {number} node
-     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
-     */
-    bind(node, tree) {
-        this.__node = node;
-        this.__tree = tree;
-    }
-
-    /**
-     *
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    set_bounds(x0, y0, z0, x1, y1, z1) {
-        this.__tree.node_set_aabb_primitive(this.__node,
-            x0, y0, z0, x1, y1, z1
-        );
-    }
-
-    disconnect() {
-        this.__tree.remove_leaf(this.__node);
-    }
-
-    destroy() {
-        this.__tree.release_node(this.__node);
-
-        this.__tree = null;
-        this.__node = -1;
-    }
-}