@woosh/meep-engine 2.51.0 → 2.52.0

package/src/core/model/reactive/js/compileReactiveToJS.spec.js

@@ -0,0 +1,14 @@
+import { compileReactiveToJS } from "./compileReactiveToJS.js";
+import { ReactiveLiteralBoolean } from "../model/terminal/ReactiveLiteralBoolean.js";
+import { ReactiveLiteralNumber } from "../model/terminal/ReactiveLiteralNumber.js";
+import { ReactiveLiteralString } from "../model/terminal/ReactiveLiteralString.js";
+
+test("literal expressions", () => {
+
+    expect(compileReactiveToJS(ReactiveLiteralBoolean.from(true))).toEqual("true");
+
+    expect(compileReactiveToJS(ReactiveLiteralNumber.from(13.1))).toEqual("13.1");
+
+    expect(compileReactiveToJS(ReactiveLiteralString.from("a"))).toEqual("'a'");
+
+});

package/src/core/model/reactive/model/logic/ReactiveAnd.spec.js

@@ -1,7 +1,7 @@
 import { ReactiveLiteralBoolean } from "../terminal/ReactiveLiteralBoolean.js";
 import { ReactiveAnd } from "./ReactiveAnd.js";
 
-test('.copy method must not change the original', () => {
+test('copy method does not modify the sources', () => {
 
     const b0 = ReactiveLiteralBoolean.from(false);
     const b1 = ReactiveLiteralBoolean.from(true);
@@ -19,3 +19,33 @@ test('.copy method must not change the original', () => {
     expect(b1.getValue()).toBe(true);
 
 });
+
+test("equals", () => {
+
+    const a = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const b = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const c = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+    const d = ReactiveAnd.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(true));
+
+    expect(a.equals(b)).toBe(true);
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+
+    expect(a.equals(ReactiveLiteralBoolean.from(true))).toBe(false);
+});
+
+test("evaluate", () => {
+    const a = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const b = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+
+    expect(a.evaluate({})).toBe(true);
+    expect(b.evaluate({})).toBe(false);
+});
+
+test("clone", () => {
+    const source = ReactiveAnd.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+
+    const clone = source.clone();
+
+    expect(clone.equals(source)).toBe(true);
+});

package/src/core/model/reactive/model/logic/ReactiveOr.spec.js

@@ -0,0 +1,53 @@
+import { ReactiveLiteralBoolean } from "../terminal/ReactiveLiteralBoolean.js";
+import { ReactiveOr } from "./ReactiveOr.js";
+
+test('copy method does not modify the sources', () => {
+
+    const b0 = ReactiveLiteralBoolean.from(false);
+    const b1 = ReactiveLiteralBoolean.from(true);
+
+    const a = new ReactiveOr();
+
+
+    a.connect(b0, b1);
+
+    const b = new ReactiveOr();
+
+    b.copy(a);
+
+    expect(b0.getValue()).toBe(false);
+    expect(b1.getValue()).toBe(true);
+
+});
+
+test("equals", () => {
+
+    const a = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const b = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const c = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+    const d = ReactiveOr.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(true));
+
+    expect(a.equals(b)).toBe(true);
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+
+    expect(a.equals(ReactiveLiteralBoolean.from(true))).toBe(false);
+});
+
+test("evaluate", () => {
+    const a = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(true));
+    const b = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+    const c = ReactiveOr.from(ReactiveLiteralBoolean.from(false), ReactiveLiteralBoolean.from(false));
+
+    expect(a.evaluate({})).toBe(true);
+    expect(b.evaluate({})).toBe(true);
+    expect(c.evaluate({})).toBe(false);
+});
+
+test("clone", () => {
+    const source = ReactiveOr.from(ReactiveLiteralBoolean.from(true), ReactiveLiteralBoolean.from(false));
+
+    const clone = source.clone();
+
+    expect(clone.equals(source)).toBe(true);
+});

package/src/core/model/stat/LinearModifier.js

@@ -13,8 +13,8 @@ class LinearModifier {
      * @constructor
      */
     constructor(a = 1, b = 0) {
-        assert.typeOf(a, 'number', 'a');
-        assert.typeOf(b, 'number', 'b');
+        assert.isNumber(a, 'a');
+        assert.isNumber(b, 'b');
 
         /**
          * gradient (slope)

package/src/core/model/stat/LinearModifier.spec.js

@@ -33,3 +33,65 @@ test("equals method", () => {
     expect(a.equals(c)).toBe(false);
     expect(a.equals(d)).toBe(false);
 });
+
+test("hash", () => {
+    const mod = new LinearModifier(3, -7);
+
+    const hash = mod.hash();
+
+    expect(mod.hash()).toEqual(hash); // idempotency
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("copy", () => {
+
+    const source = new LinearModifier(3, -7);
+    const target = new LinearModifier(1, 1);
+
+    target.copy(source);
+
+    expect(target.a).toBe(3);
+    expect(target.b).toBe(-7);
+
+    // check that original was not changed
+
+    expect(source.a).toBe(3);
+    expect(source.b).toBe(-7);
+});
+
+test("clone", () => {
+
+    const source = new LinearModifier(3, -7);
+
+    const clone = source.clone();
+
+    expect(clone.equals(source)).toBe(true);
+
+});
+
+test("to/from JSON consistency", () => {
+
+    const source = new LinearModifier(3, -7);
+    const target = new LinearModifier(1, 1);
+
+    target.fromJSON(source.toJSON());
+
+    expect(target.a).toBe(3);
+    expect(target.b).toBe(-7);
+
+    // check that original was not changed
+
+    expect(source.a).toBe(3);
+    expect(source.b).toBe(-7);
+});
+
+test("toString produces a valid string", () => {
+
+    const s = new LinearModifier(3, -7).toString();
+
+    expect(typeof s).toBe("string");
+    expect(s.trim().length).toBeGreaterThan(0);
+
+});
+

package/src/core/model/stat/Stat.js

@@ -140,6 +140,15 @@ class Stat extends Number {
         this.updateValue();
     }
 
+    /**
+     *
+     * @param {LinearModifier} mod
+     * @return {boolean}
+     */
+    hasModifier(mod) {
+        return this.__modifiers.contains(mod);
+    }
+
     /**
      *
      * @param {LinearModifier} mod
@@ -174,6 +183,8 @@ class Stat extends Number {
     copy(other) {
         this.base.copy(other.base);
         this.__modifiers.copy(other.__modifiers);
+
+        this.updateValue();
     }
 
     /**
@@ -226,6 +237,7 @@ class Stat extends Number {
     fromJSON(json) {
         this.base.fromJSON(json.base);
         this.__modifiers.fromJSON(json.modifiers, LinearModifier);
+        this.updateValue();
     }
 
     /**

package/src/core/model/stat/Stat.spec.js

@@ -73,3 +73,39 @@ test("order of modifiers doesn't matter", () => {
         expect(s.getValue()).toEqual(-45);
     }
 });
+
+test("toString produces a valid string", () => {
+    const stat = new Stat(1);
+
+    const s = stat.toString();
+
+    expect(typeof s).toBe("string");
+    expect(s.trim().length).toBeGreaterThan(0);
+});
+
+test("copy", () => {
+    const source = new Stat(7);
+
+    source.addModifier(LinearModifier.CONSTANT_ONE);
+
+    const other = new Stat(1);
+
+    other.copy(source);
+
+    expect(other.getBaseValue()).toBe(7);
+    expect(other.hasModifier(LinearModifier.CONSTANT_ONE));
+
+    expect(other.equals(source)).toBe(true);
+});
+
+test("to/from JSON consistency", () => {
+
+    const source = new Stat(7);
+    source.addModifier(LinearModifier.CONSTANT_ONE);
+
+    const destination = new Stat(1);
+
+    destination.fromJSON(source.toJSON());
+
+    expect(destination.equals(source)).toBe(true);
+});

package/src/core/primitives/array/computeStridedIntegerArrayHash.spec.js

@@ -0,0 +1,28 @@
+import { computeStridedIntegerArrayHash } from "./computeStridedIntegerArrayHash.js";
+
+/**
+ *
+ * @param {number[]} value
+ * @param {number} [stride]
+ */
+function check(value, stride = 1) {
+    const hash = computeStridedIntegerArrayHash(value, 0, value.length, 1);
+
+    expect(typeof hash).toBe('number');
+    expect(Number.isInteger(hash)).toBe(true);
+
+}
+
+test("sanity", () => {
+
+    check([], 1);
+
+    check([1], 1);
+    check([1], 3);
+
+    check([1, 3], 1);
+    check([1, 3], 3);
+
+    check([1, 3, 7], 3);
+
+});

package/src/core/primitives/numbers/number_format_by_thousands.js

@@ -0,0 +1,14 @@
+import { assert } from "../../assert.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {string} [separator=',']
+ * @returns {string}
+ */
+export function number_format_by_thousands(x, separator = ',') {
+    assert.isNumber(x, 'x');
+    assert.isString(separator, 'separator');
+
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+}

package/src/core/primitives/numbers/number_pretty_print.js

@@ -0,0 +1,49 @@
+import { assert } from "../../assert.js";
+import { number_format_by_thousands } from "./number_format_by_thousands.js";
+
+/**
+ *
+ * @param {string} value
+ * @returns {number}
+ */
+function countDecimals(value) {
+    if (value % 1 === 0) {
+        //whole number
+        return 0;
+    }
+    const s = value.toString();
+    const index = s.indexOf('.');
+
+    if (index === -1) {
+        return 0;
+    }
+
+    //find last 0
+    let endIndex = s.length - 1;
+    for (; endIndex > index && s.charAt(endIndex) === "0"; endIndex--) {
+
+    }
+    return endIndex - index;
+}
+
+/**
+ *
+ * @param {number} value
+ * @returns {string|number}
+ */
+export function number_pretty_print(value) {
+    assert.isNumber(value, 'value');
+
+    const MAX_DECIMALS = 2;
+
+    const fraction = value % 1;
+    if (fraction !== 0 && Math.abs(value) < 100) {
+        const decimals = countDecimals(value.toFixed(MAX_DECIMALS));
+        const decimalsToPrint = Math.min(decimals, MAX_DECIMALS);
+        return value.toFixed(decimalsToPrint);
+    } else {
+        //no fraction
+        return number_format_by_thousands(value - fraction, ",");
+    }
+
+}

package/src/core/primitives/strings/computeStringHash.spec.js

@@ -1,13 +1,20 @@
 import { computeStringHash } from "./computeStringHash.js";
 
-test('hash', () => {
+function check(value) {
     // must produce a number
-    expect(typeof computeStringHash('')).toBe('number');
+    const hash = computeStringHash(value);
+    expect(typeof hash).toBe('number');
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(computeStringHash(value)).toEqual(hash); // stability
+}
 
-    // check for identical results from identical inputs
-    expect(computeStringHash('')).toBe(computeStringHash(''));
+test('hash', () => {
 
-    expect(computeStringHash('cat')).toBe(computeStringHash('cat'));
+    check('');
+    check('cat');
+    check('tomato');
+    check(null);
+    check(undefined);
 
     expect(computeStringHash('tomato')).not.toBe(computeStringHash('potato'));
 });

package/src/core/process/BaseProcess.js

@@ -4,14 +4,14 @@ import ObservedEnum from "../model/ObservedEnum.js";
 import { ProcessState } from "./ProcessState.js";
 
 export class BaseProcess {
-    constructor() {
-        this.id = "";
-        /**
-         * @readonly
-         * @type {ObservedEnum.<ProcessState>}
-         */
-        this.__state = new ObservedEnum(ProcessState.New, ProcessState);
-    }
+
+    id = "";
+    /**
+     * @readonly
+     * @type {ObservedEnum.<ProcessState>}
+     */
+    __state = new ObservedEnum(ProcessState.New, ProcessState);
+
 
     /**
      * @returns {ObservedEnum<ProcessState>}

package/src/engine/Clock.js

@@ -5,16 +5,15 @@
 
 import Stat from "../core/model/stat/Stat.js";
 
+//Use highest available resolution time source
+const source = typeof performance === "undefined" ? Date : performance;
 
 /**
  *
  * @returns {number}
  */
 export function currentTimeInSeconds() {
-    //Use highest available resolution time source
-    const source = typeof performance === "undefined" ? Date : performance;
-
-    return source.now() / 1000;
+    return source.now() * 0.001;
 }
 
 /**
@@ -29,35 +28,37 @@ function updateElapsedTime(clock) {
 }
 
 class Clock {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__lastMeasurement = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.elapsedTime = 0;
 
-        this.timeAtDelta = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __lastMeasurement = 0;
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__isRunning = false;
+    /**
+     *
+     * @type {number}
+     */
+    elapsedTime = 0;
+
+    timeAtDelta = 0;
+
+    /**
+     *
+     * @type {boolean}
+     * @private
+     */
+    __isRunning = false;
 
 
-        /**
-         * how fast clock ticks in relation to real time
-         * @type {Stat}
-         */
-        this.speed = new Stat(1);
+    /**
+     * how fast clock ticks in relation to real time
+     * @type {Stat}
+     */
+    speed = new Stat(1);
+
+    constructor() {
         this.speed.postprocess = Stat.Process.clampMin(0);
     }
 

package/src/engine/Clock.spec.js

@@ -0,0 +1,26 @@
+import Clock from "./Clock.js";
+import { delay } from "../core/process/delay.js";
+
+test("constructor does not throw", () => {
+    new Clock();
+});
+
+test("reset", () => {
+    const clock = new Clock();
+    clock.reset();
+
+    expect(clock.getElapsedTime()).toBe(0);
+    expect(clock.getDelta()).toBe(0);
+});
+
+test("getDelta", async () => {
+    const clock = new Clock();
+
+    clock.start();
+
+    await delay(30);
+
+    const delta = clock.getDelta();
+
+    expect(delta).toBeCloseTo(0.03, 0.01);
+});

package/src/engine/ecs/EntityBuilder.js

@@ -229,7 +229,7 @@ class EntityBuilder {
     /**
      *
      * @param {string} eventName
-     * @param {*} event
+     * @param {*} [event]
      */
     sendEvent(eventName, event) {
         if (this.getFlag(EntityBuilderFlags.Built)) {
@@ -368,6 +368,8 @@ class EntityBuilder {
             const subscription = listeners[i];
             dataset.addEntityEventListener(entity, subscription.name, subscription.listener, subscription.context);
         }
+        // reset listeners
+        this.deferredListeners.splice(0, listeners_count);
 
         const element = this.element;
         const element_count = element.length;

package/src/engine/ecs/EntityBuilder.spec.js

@@ -55,13 +55,18 @@ test("'Built' flag is reset when entity is removed without invoking 'destroy' me
 
     const b = new EntityBuilder();
 
+    expect(b.getFlag(EntityBuilderFlags.Built)).toBe(false);
+    expect(b.isBuilt).toBe(false);
+
     b.build(dataset);
 
     expect(b.getFlag(EntityBuilderFlags.Built)).toBe(true);
+    expect(b.isBuilt).toBe(true);
 
     dataset.removeEntity(b.entity);
 
     expect(b.getFlag(EntityBuilderFlags.Built)).toBe(false);
+    expect(b.isBuilt).toBe(false);
 });
 
 test("removeAllComponents from empty", () => {
@@ -131,4 +136,20 @@ test("adding component to live entity results in component being added to the da
     entity.add(component);
 
     expect(ecd.getComponent(entity.entity, DummyComponent)).toBe(component);
+
+});
+
+test("promiseEvent", async () => {
+
+    const entity = new EntityBuilder();
+
+    const ecd = sampleDataset();
+
+    entity.build(ecd)
+
+    const promise = entity.promiseEvent("x");
+
+    entity.sendEvent("x");
+
+    await promise;
 });

package/src/engine/ecs/gui/GUIElement.js

@@ -171,7 +171,7 @@ class GUIElement {
         return computeHashIntegerArray(
             this.flags,
             computeStringHash(this.klass),
-            this.anchor.hashCode(),
+            this.anchor.hash(),
             computeStringHash(this.group),
             this.visible.hashCode()
         )

package/src/engine/ecs/gui/position/ViewportPosition.js

@@ -97,9 +97,9 @@ class ViewportPosition {
 
     hash() {
         return computeHashIntegerArray(
-            this.position.hashCode(),
-            this.offset.hashCode(),
-            this.anchor.hashCode(),
+            this.position.hash(),
+            this.offset.hash(),
+            this.anchor.hash(),
             this.resolveGuiCollisions ? 1 : 0,
             computeHashFloat(this.screenEdgeWidth),
             this.stickToScreenEdge ? 1 : 0,

package/src/engine/ecs/terrain/ecs/TerrainClassifier.js

@@ -52,7 +52,7 @@ function classify(terrain, mask) {
 
     const maxSamples = 50;
 
-    const hash = maskCenter.hashCode();
+    const hash = maskCenter.hash();
 
     /**
      *

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -50,7 +50,7 @@ class ScaledTextureKey {
     }
 
     hash() {
-        return computeStringHash(this.uri) ^ this.size.hashCode();
+        return computeStringHash(this.uri) ^ this.size.hash();
     }
 
     equals(other) {

package/src/engine/ecs/transform/Transform.js

@@ -25,6 +25,7 @@ const scratch_matrix = new Float32Array(16);
 const FLAGS_DEFAULT = TransformFlags.AutomaticChangeDetection;
 
 /**
+ * Described position/rotation/scale in 3d space
  * @class
  */
 export class Transform {

package/src/engine/graphics/camera/testClippingPlaneComputation.js

@@ -26,7 +26,6 @@ import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSyste
 import { GridPosition2TransformSystem } from "../../grid/systems/GridPosition2TransformSystem.js";
 import { Transform2GridPositionSystem } from "../../grid/transform2grid/Transform2GridPositionSystem.js";
 import SynchronizePositionSystem from "../../ecs/systems/SynchronizePositionSystem.js";
-import GridObstacleSystem from "../../grid/systems/GridObstacleSystem.js";
 import GridPositionSystem from "../../grid/systems/GridPositionSystem.js";
 import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
 import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
@@ -37,7 +36,6 @@ import { AnimationGraphSystem } from "../ecs/animation/animator/AnimationGraphSy
 import { FogOfWarSystem } from "../../ecs/fow/FogOfWarSystem.js";
 import { FogOfWarRevealerSystem } from "../../ecs/fow/FogOfWarRevealerSystem.js";
 import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
-import { SerializationMetadataSystem } from "../../ecs/systems/SerializationMetadataSystem.js";
 import { InverseKinematicsSystem } from "../../ecs/ik/InverseKinematicsSystem.js";
 import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
 import RenderSystem from "../../ecs/systems/RenderSystem.js";
@@ -105,7 +103,6 @@ function makeConfig(engine) {
         new GridPosition2TransformSystem(),
         new Transform2GridPositionSystem(),
         new SynchronizePositionSystem(),
-        new GridObstacleSystem(),
         new GridPositionSystem(),
         new InputControllerSystem(devices),
         new InputSystem(devices),
@@ -119,7 +116,6 @@ function makeConfig(engine) {
         new FogOfWarSystem(graphics),
         new FogOfWarRevealerSystem(0),
         new BehaviorSystem(engine),
-        new SerializationMetadataSystem(),
         new InverseKinematicsSystem(),
         new PathDisplaySystem(engine),
     );

package/src/engine/graphics/ecs/animation/animator/graph/AnimationGraph.spec.js

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