@woosh/meep-engine 2.51.0 → 2.53.0

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/Engine.spec.js

@@ -1,3 +1,7 @@
+/**
+ * @jest-environment jsdom
+ */
+
 import Engine from "./Engine.js";
 import { InMemoryEnginePlatform } from "./platform/InMemoryEnginePlatform.js";
 

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/EntityComponentDataset.js

@@ -185,7 +185,7 @@ export class EntityComponentDataset {
 
         /**
          *
-         * @type {Array<SignalHandler>[]}
+         * @type {SignalHandler[][]}
          * @private
          */
         this.__entityAnyEventListeners = [];

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

@@ -1,6 +1,6 @@
 import { EntityObserver } from "./EntityObserver.js";
 import { Transform } from "./transform/Transform.js";
-import GridPosition from "../grid/components/GridPosition.js";
+import GridPosition from "../grid/position/GridPosition.js";
 import EntityBuilder from "./EntityBuilder.js";
 import { EntityComponentDataset } from "./EntityComponentDataset.js";
 import { noop } from "../../core/function/Functions.js";

package/src/engine/ecs/dynamic_actions/actions/definition/{WhiteToBlackboardActionDescription.js → WriteToBlackboardActionDescription.js}

@@ -4,7 +4,7 @@ import { Blackboard } from "../../../../intelligence/blackboard/Blackboard.js";
 import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 import { assert } from "../../../../../core/assert.js";
 
-export class WhiteToBlackboardActionDescription extends AbstractActionDescription {
+export class WriteToBlackboardActionDescription extends AbstractActionDescription {
     constructor() {
         super();
 
@@ -55,4 +55,4 @@ export class WhiteToBlackboardActionDescription extends AbstractActionDescriptio
 }
 
 
-WhiteToBlackboardActionDescription.prototype.type = "Write";
+WriteToBlackboardActionDescription.prototype.type = "Write";

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

@@ -5,7 +5,7 @@ import { ActionSequenceDescription } from "./ActionSequenceDescription.js";
 import { DelayActionDescription } from "./DelayActionDescription.js";
 import { NoopActionDescription } from "./NoopActionDescription.js";
 import { WeightedRandomActionDescription } from "./WeightedRandomActionDescription.js";
-import { WhiteToBlackboardActionDescription } from "./WhiteToBlackboardActionDescription.js";
+import { WriteToBlackboardActionDescription } from "./WriteToBlackboardActionDescription.js";
 
 const type_map = {
     Sequence({ elements }) {
@@ -59,7 +59,7 @@ registerType(SpeakLineActionDescription);
 registerType(SendRequestActionDescription);
 registerType(DelayActionDescription);
 registerType(NoopActionDescription);
-registerType(WhiteToBlackboardActionDescription);
+registerType(WriteToBlackboardActionDescription);
 
 /**
  *

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/guid/GUIDSerializationAdapter.spec.js

@@ -0,0 +1,21 @@
+import { GUID } from "./GUID.js";
+import { GUIDSerializationAdapter } from "./GUIDSerializationAdapter.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+test("to/from consistency", () => {
+
+    const source = GUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+
+    const adapter = new GUIDSerializationAdapter();
+
+    const buffer = new BinaryBuffer();
+
+    adapter.serialize(buffer, source);
+    buffer.position = 0; // rewind
+
+    const destination = new GUID();
+
+    adapter.deserialize(buffer, destination);
+
+    expect(destination.equals(source)).toBe(true);
+});

package/src/engine/ecs/parent/EntityNode.js

@@ -98,7 +98,7 @@ export class EntityNode {
 
     /**
      *
-     * @param {(node:EntityNode)=>*} visitor
+     * @param {function(node:EntityNode):*} visitor
      * @param {*} [thisArg]
      */
     traverse(visitor, thisArg) {

package/src/engine/ecs/parent/EntityNode.spec.js

@@ -0,0 +1,104 @@
+import { EntityNode } from "./EntityNode.js";
+import { EntityComponentDataset } from "../EntityComponentDataset.js";
+
+test("constructor does not throw", () => {
+    new EntityNode()
+});
+
+test("setFlag", () => {
+    const ut = new EntityNode();
+
+    ut.setFlag(0b101);
+
+    expect(ut.flags).toBe(5);
+
+    ut.setFlag(0b010);
+
+    expect(ut.flags).toBe(7);
+
+    ut.setFlag(0b1);
+
+    expect(ut.flags).toBe(7);
+});
+
+test("clearFlag", () => {
+    const ut = new EntityNode();
+    ut.flags = 0b101;
+
+    ut.clearFlag(0b1);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b10);
+
+    expect(ut.flags).toBe(4);
+
+    ut.clearFlag(0b100);
+
+    expect(ut.flags).toBe(0);
+});
+
+test("getFlag", () => {
+
+    const ut = new EntityNode();
+
+    ut.flags = 0b101;
+
+    expect(ut.getFlag(0b1)).toBe(true);
+    expect(ut.getFlag(0b10)).toBe(false);
+    expect(ut.getFlag(0b100)).toBe(true);
+    expect(ut.getFlag(0b1000)).toBe(false);
+    expect(ut.getFlag(0b101)).toBe(true);
+    expect(ut.getFlag(0b011)).toBe(false);
+});
+
+test("writeFlag", () => {
+    const ut = new EntityNode();
+
+    ut.writeFlag(0b101, true);
+    expect(ut.flags).toBe(5);
+
+    ut.writeFlag(0b100, false);
+
+    expect(ut.flags).toBe(1);
+});
+
+test("traverse without children", () => {
+    const node = new EntityNode();
+
+    const visited = [];
+
+    node.traverse(Array.prototype.push, visited);
+
+    expect(visited.length).toBe(1);
+    expect(visited).toContain(node);
+});
+
+test("build empty", () => {
+    const node = new EntityNode();
+
+    const dataset = new EntityComponentDataset();
+
+    node.build(dataset);
+
+    expect(node.isBuilt).toBe(true);
+    expect(node.entity.isBuilt).toBe(true);
+    expect(dataset.entityExists(node.entity.entity)).toBe(true);
+});
+
+test("destroy empty", () => {
+    const node = new EntityNode();
+
+    const dataset = new EntityComponentDataset();
+
+    node.build(dataset);
+
+    const entity = node.entity.entity;
+
+    node.destroy();
+
+    expect(node.isBuilt).toBe(false);
+    expect(node.entity.isBuilt).toBe(false);
+    expect(dataset.entityExists(entity)).toBe(false);
+
+});

package/src/engine/ecs/speaker/Voice.js

@@ -55,4 +55,8 @@ export class Voice {
  */
 Voice.serializable = false;
 
+/**
+ * @readonly
+ * @type {string}
+ */
 Voice.typeName = 'Voice';

package/src/engine/ecs/team/Team.js

@@ -2,7 +2,6 @@
  * Created by Alex on 13/04/2016.
  */
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 
 class Team extends ObservedInteger {
     /**
@@ -37,46 +36,3 @@ Team.typeName = "Team";
 
 export default Team;
 
-export class TeamSerializationAdapter extends BinaryClassSerializationAdapter{
-    constructor(){
-        super();
-
-        this.klass = Team;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Team} value
-     */
-    serialize(buffer, value) {
-        const v = value.getValue();
-
-        if (v === Infinity) {
-            buffer.writeInt32(2147483647);
-        } else if (v === -Infinity) {
-            buffer.writeInt32(-2147483648);
-        } else {
-            //TODO it's possible to write encoded Infinity values by accident
-            buffer.writeInt32(v);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Team} value
-     */
-    deserialize(buffer, value) {
-        const v = buffer.readInt32();
-
-        if (v === 2147483647) {
-            value.set(Infinity);
-        } else if (v === -2147483648) {
-            value.set(-Infinity);
-        } else {
-            value.set(v);
-        }
-    }
-}

package/src/engine/ecs/team/TeamSerializationAdapter.js

@@ -0,0 +1,46 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import Team from "./Team.js";
+
+export class TeamSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = Team;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    serialize(buffer, value) {
+        const v = value.getValue();
+
+        if (v === Infinity) {
+            buffer.writeInt32(2147483647);
+        } else if (v === -Infinity) {
+            buffer.writeInt32(-2147483648);
+        } else {
+            //TODO it's possible to write encoded Infinity values by accident
+            buffer.writeInt32(v);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    deserialize(buffer, value) {
+        const v = buffer.readInt32();
+
+        if (v === 2147483647) {
+            value.set(Infinity);
+        } else if (v === -2147483648) {
+            value.set(-Infinity);
+        } else {
+            value.set(v);
+        }
+    }
+}

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 {
@@ -302,7 +303,7 @@ export class Transform {
     }
 
     /**
-     *
+     * Write out the current transform to a supplied container
      * @param {number[]|Float32Array} result
      */
     toMatrix4(result) {

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

@@ -149,3 +149,27 @@ test("writeFlag", () => {
 
     expect(ut.flags).toBe(1);
 });
+
+test("toMatrix from identity transform", () => {
+    const t = new Transform();
+
+    t.makeIdentity();
+
+    const matrix = [];
+
+    t.toMatrix4(matrix);
+
+    expect(matrix).toEqual(Array.from(MATRIX_4_IDENTITY));
+});
+
+test("hash", () => {
+
+    const t = new Transform();
+
+    const hash = t.hash();
+
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(t.hash()).toEqual(hash);
+
+});

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

@@ -23,11 +23,10 @@ import WaterSystem from "../ecs/water/WaterSystem.js";
 import Trail2DSystem from "../ecs/trail2d/Trail2DSystem.js";
 import { Foliage2System } from "../../ecs/foliage/ecs/Foliage2System.js";
 import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
-import { GridPosition2TransformSystem } from "../../grid/systems/GridPosition2TransformSystem.js";
+import { GridPosition2TransformSystem } from "../../grid/grid2transform/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 GridPositionSystem from "../../grid/position/GridPositionSystem.js";
 import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
 import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
 import MeshHighlightSystem from "../ecs/highlight/system/MeshHighlightSystem.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()
+});

package/src/engine/graphics/ecs/animation/animator/graph/definition/AnimationGraphDefinition.js

@@ -9,31 +9,30 @@ import { computeHashIntegerArray } from "../../../../../../../core/collection/ar
 import { isArrayEqual } from "../../../../../../../core/collection/array/isArrayEqual.js";
 
 export class AnimationGraphDefinition {
-    constructor() {
-        /**
-         *
-         * @type {AnimationStateDefinition[]}
-         */
-        this.states = [];
-
-        /**
-         *
-         * @type {AnimationTransitionDefinition[]}
-         */
-        this.transitions = [];
-
-        /**
-         *
-         * @type {AnimationStateDefinition}
-         */
-        this.startingSate = null;
-
-        /**
-         *
-         * @type {AnimationClipDefinition[]}
-         */
-        this.clipIndex = [];
-    }
+
+    /**
+     *
+     * @type {AnimationStateDefinition[]}
+     */
+    states = [];
+
+    /**
+     *
+     * @type {AnimationTransitionDefinition[]}
+     */
+    transitions = [];
+
+    /**
+     *
+     * @type {AnimationStateDefinition}
+     */
+    startingSate = null;
+
+    /**
+     *
+     * @type {AnimationClipDefinition[]}
+     */
+    clipIndex = [];
 
     /**
      *

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

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