@woosh/meep-engine 2.49.9 → 2.50.1

package/src/core/geom/Vector3.spec.js

@@ -45,3 +45,63 @@ test('addVectors', () => {
     expect(ut.y).toBe(14);
     expect(ut.z).toBe(18);
 });
+
+test("equals", () => {
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 3)))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(5, -2, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, 5, 3)))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).equals(new Vector3(1, -2, 5)))
+        .toBe(false);
+});
+
+test("roughlyEquals", () => {
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.01, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.99, -2, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(0.89, -2, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1.11, -2, 3), 0.1))
+        .toBe(false);
+
+    // Y
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.01, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.99, 3), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2.11, 3), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -1.89, 3), 0.1))
+        .toBe(false);
+
+    // Z
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.01), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.99), 0.1))
+        .toBe(true);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 2.89), 0.1))
+        .toBe(false);
+
+    expect(new Vector3(1, -2, 3).roughlyEquals(new Vector3(1, -2, 3.11), 0.1))
+        .toBe(false);
+});

package/src/core/graph/GraphUtils.js

@@ -3,7 +3,9 @@
  */
 
 
-import { computeLine2Intersection } from "../geom/2d/LineSegment2.js";
+import {
+    line_segment_compute_line_segment_intersection_vectors_array_2d
+} from "../geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js";
 
 const Utils = {};
 
@@ -155,7 +157,7 @@ function graph2paths(graph, thickness) {
         const l = edges.length;
         for (; i < l; i++) {
             const edge = edges[i];
-            if (computeLine2Intersection(from, to, edge.first, edge.second)) {
+            if (line_segment_compute_line_segment_intersection_vectors_array_2d(from, to, edge.first, edge.second)) {
                 return true;
             }
         }

package/src/core/graph/layout/CircleLayout.js

@@ -6,7 +6,6 @@
 import { assert } from "../../assert.js";
 import Circle from "../../geom/2d/circle/Circle.js";
 import AABB2 from "../../geom/2d/aabb/AABB2.js";
-import { line2SegmentsIntersect } from "../../geom/2d/LineSegment2.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
@@ -14,6 +13,9 @@ import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js"
 import { Connection } from "./Connection.js";
 import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 import { applyCentralGravityAABB2 } from "./box/applyCentralGravityAABB2.js";
+import {
+    line_segment_line_segment_intersection_exists_2d
+} from "../../geom/2d/line/line_segment_line_segment_intersection_exists_2d.js";
 
 
 /**
@@ -364,7 +366,7 @@ function computeNumberOfCrossOvers(edges, numEdges) {
             const b0 = e1.source;
             const b1 = e1.target;
 
-            if (line2SegmentsIntersect(
+            if (line_segment_line_segment_intersection_exists_2d(
                 a0.x, a0.y,
                 a1.x, a1.y,
                 b0.x, b0.y,

package/src/core/math/vector_nd_dot.js

@@ -0,0 +1,16 @@
+/**
+ * N-dimensional vector dot product
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} n number of dimensions
+ * @return {number}
+ */
+export function vector_nd_dot(a, b, n) {
+    let result = 0;
+
+    for (let i = 0; i < n; i++) {
+        result += a[i] * b[i]
+    }
+
+    return result;
+}

package/src/core/math/{normalizeArrayVector.js → vector_nd_normalize.js}

@@ -1,10 +1,10 @@
 /**
  * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
- * @param {number[]|Float32Array} result
- * @param {number[]|Float32Array} data
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number[]|Float32Array|Float64Array} data
  * @param {number} [length] number of dimensions
  */
-export function normalizeArrayVector(result, data, length = data.length) {
+export function vector_nd_normalize(result, data, length = data.length) {
 
     let magnitude2 = 0;
 

package/src/core/math/{normalizeArrayVector.spec.js → vector_nd_normalize.spec.js}

@@ -1,15 +1,15 @@
-import { normalizeArrayVector } from "./normalizeArrayVector.js";
+import { vector_nd_normalize } from "./vector_nd_normalize.js";
 
 test("1d vector normalization", () => {
     const v = [7];
 
-    normalizeArrayVector(v, v, 1);
+    vector_nd_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(1);
 
     v[0] = -13;
 
-    normalizeArrayVector(v, v, 1);
+    vector_nd_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(-1);
 });

package/src/core/process/PromiseWatcher.spec.js

@@ -16,7 +16,7 @@ function trigger() {
     return {
         promise,
         reject(r) {
-            _reject(r)
+            setTimeout(() => _reject(r), 1);
         },
         resolve(v) {
             _resolve(v);

package/src/engine/animation/curve/compression/downsample_float_array_curve_by_error.js

@@ -6,7 +6,7 @@ import { lerp } from "../../../../core/math/lerp.js";
 import { min3 } from "../../../../core/math/min3.js";
 import { max3 } from "../../../../core/math/max3.js";
 import { downsample_float_array } from "./downsample_float_array.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { isPowerOfTwo } from "../../../../core/math/isPowerOrTwo.js";
 
 /**

package/src/engine/ecs/EntityBlueprint.d.ts

@@ -1,3 +1,17 @@
+import EntityBuilder from "./EntityBuilder";
+
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
 export class EntityBlueprint {
     static from(components: any[]): EntityBlueprint
+
+    add<T>(component: T): void
+
+    addJSON<T>(klass: Type<T>, json: any): void
+
+    clear(): void
+
+    build(seed?: object): EntityBuilder
 }

package/src/engine/ecs/EntityBlueprint.js

@@ -140,10 +140,10 @@ export class EntityBlueprint {
 
 
     /**
-     *
+     * @param {object} [templateSeed]
      * @return {EntityBuilder}
      */
-    buildEntityBuilder(templateSeed) {
+    build(templateSeed) {
         const eb = new EntityBuilder();
 
         this.componentnts.forEach((template, ComponentClass) => {

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

@@ -0,0 +1,52 @@
+import { EntityBlueprint } from "./EntityBlueprint.js";
+import EntityBuilder from "./EntityBuilder.js";
+
+test("constructor does not throw", () => {
+
+    expect(() => new EntityBlueprint()).not.toThrow();
+
+});
+
+test("build empty", () => {
+    const blueprint = new EntityBlueprint();
+
+    const entity = blueprint.build();
+
+    expect(entity).toBeDefined();
+    expect(entity).toBeInstanceOf(EntityBuilder);
+    expect(entity.count).toEqual(0);
+});
+
+class DummyComponent {
+    a = 0
+
+    fromJSON({ a }) {
+        this.a = a;
+    }
+}
+
+test("a copy of the added component ends up on built entity", () => {
+
+    const blueprint = new EntityBlueprint();
+
+    blueprint.addJSON(DummyComponent, { a: 7 });
+
+    const entity = blueprint.build();
+
+    const retrieved = entity.getComponent(DummyComponent);
+
+    expect(retrieved).toBeInstanceOf(DummyComponent);
+    expect(retrieved.a).toEqual(7);
+});
+
+test("seed template", () => {
+    const blueprint = new EntityBlueprint();
+
+    blueprint.addJSON(DummyComponent, { a: '$x' });
+
+    const entity = blueprint.build({ x: 13 });
+
+    const component = entity.getComponent(DummyComponent);
+
+    expect(component.a).toEqual(13);
+});

package/src/engine/ecs/EntityBuilder.js

@@ -125,6 +125,14 @@ class EntityBuilder {
         }
     }
 
+    /**
+     * Number of attached components
+     * @return {number}
+     */
+    get count() {
+        return this.element.length;
+    }
+
     /**
      * @template T
      * @param {T} componentInstance

package/src/engine/ecs/EntityManager.d.ts

@@ -8,6 +8,7 @@ interface Type<T> extends Function {
 
 export class EntityManager {
     dataset: EntityComponentDataset
+    fixedUpdateStepSize: number
 
     getComponentTypeMap(): any[]
 

package/src/engine/ecs/EntityManager.js

@@ -329,6 +329,9 @@ EntityManager.prototype.simulate = function (timeDelta) {
     const fixed_step = this.fixedUpdateStepSize;
     const accumulatedTime = this.systemAccumulatedFixedStepTime;
 
+    assert.notNaN(fixed_step, 'fixed_step');
+    assert.greaterThan(fixed_step, 0, 'fixed_step must be greater than 0');
+
     for (let i = 0; i < system_count; i++) {
 
         const system = systems[i];
@@ -337,7 +340,7 @@ EntityManager.prototype.simulate = function (timeDelta) {
             let accumulated_time = accumulatedTime.get(system) + timeDelta;
 
 
-            while (accumulated_time > fixed_step) {
+            while (accumulated_time >= fixed_step) {
 
                 try {
                     system.fixedUpdate(fixed_step)
@@ -458,9 +461,10 @@ function validateSystem(system) {
 /**
  * If the {@link EntityManager} is already started, the system will be started automatically before being added
  * @param {System} system
+ * @returns {Promise}
  * @throws {IllegalStateException}
  */
-EntityManager.prototype.addSystem = async function (system) {
+EntityManager.prototype.addSystem = function (system) {
     assert.defined(system, "system");
     assert.isInstanceOf(system, System, 'system', 'System');
 
@@ -469,7 +473,7 @@ EntityManager.prototype.addSystem = async function (system) {
     if (existing !== null) {
         if (existing === system) {
             //system already added, do nothing
-            return;
+            return Promise.resolve();
         } else {
             throw new IllegalStateException(`Another instance of system '${computeSystemName(system)}' is already registered`);
         }
@@ -508,7 +512,7 @@ EntityManager.prototype.addSystem = async function (system) {
     if (this.state === EntityManagerState.Running) {
         //initialize the system
         startup_promise = new Promise((resolve, reject) => {
-            system.startup(this, resolve, reject);
+            this.startSystem(system, resolve, reject);
         });
     } else {
         startup_promise = Promise.resolve();
@@ -526,13 +530,13 @@ EntityManager.prototype.addSystem = async function (system) {
 
     this.on.systemAdded.send1(system);
 
-    await startup_promise;
+    return startup_promise;
 };
 
 /**
  *
  * @param {System} system
- * @returns {boolean}
+ * @returns {Promise<boolean>}
  */
 EntityManager.prototype.removeSystem = async function (system) {
     assert.defined(system, "system");
@@ -573,11 +577,13 @@ EntityManager.prototype.removeSystem = async function (system) {
     this.systemAccumulatedFixedStepTime.delete(system);
 
     this.on.systemRemoved.send1(system);
+
+    return true;
 };
 
 
 /**
- *
+ * @private
  * @param {System} system
  * @param {function(system: System)} successCallback
  * @param {function(reason:*)} errorCallback
@@ -614,13 +620,15 @@ EntityManager.prototype.stopSystem = function (system, successCallback, errorCal
 };
 
 /**
- *
+ * @private
  * @param {System} system
  * @param {function(system: System)} successCallback
  * @param {function(reason:*)} errorCallback
  */
 EntityManager.prototype.startSystem = function (system, successCallback, errorCallback) {
     assert.defined(system, "system");
+    assert.isFunction(successCallback, "successCallback");
+    assert.isFunction(errorCallback, "errorCallback");
 
     if (system.state.getValue() === System.State.RUNNING) {
         //system is already running
@@ -831,7 +839,7 @@ EntityManager.prototype.shutdown = function (readyCallback, errorCallback) {
 
         system.state.set(System.State.STOPPED);
 
-        self.on.systemStopped.dispatch(system);
+        self.on.systemStopped.send1(system);
         if (readyCount === expectedReadyCount) {
             finalizeShutdown();
         }
@@ -870,210 +878,6 @@ EntityManager.prototype.shutdown = function (readyCallback, errorCallback) {
     });
 };
 
-
-/**
- * @deprecated
- * @returns {number}
- */
-EntityManager.prototype.createEntity = function () {
-    console.warn("EntityManager.createEntity is deprecated");
-
-    return this.dataset.createEntity();
-};
-
-/**
- * @deprecated
- * @param id
- */
-EntityManager.prototype.createEntitySpecific = function (id) {
-    console.warn("EntityManager.createEntitySpecific is deprecated");
-    this.dataset.createEntitySpecific(id);
-};
-
-
-/**
- * @deprecated
- * Remove association of specified component type from entity
- * @param {Number} entityId
- * @param {Number} componentType
- */
-EntityManager.prototype.removeComponentFromEntity = function (entityId, componentType) {
-    console.warn("EntityManager.removeComponentFromEntity is deprecated");
-
-    this.dataset.removeComponentFromEntityByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated use dataset directly
- * Retrieves component instance associated with entity
- * @template T
- * @param {Number} entityId
- * @param {class.<T>} componentClass
- * @returns {T|null}
- * @nosideeffects
- */
-EntityManager.prototype.getComponent = function (entityId, componentClass) {
-    console.warn("EntityManager.getComponent is deprecated");
-
-    return this.dataset.getComponent(entityId, componentClass);
-};
-
-/**
- * @deprecated use {@link EntityComponentDataset.entityExists} instead
- * @param {number} entityIndex
- * @returns {boolean}
- */
-EntityManager.prototype.entityExists = function (entityIndex) {
-    console.warn("EntityManager.entityExists is deprecated");
-    if (this.dataset === null) {
-        //no dataset - no entities
-        return false;
-    }
-    return this.dataset.entityExists(entityIndex);
-};
-
-
-/**
- * @deprecated Use {@link EntityManager#dataset} direction
- * @param entity
- * @returns {Array}
- */
-EntityManager.prototype.getComponents = function (entity) {
-    console.warn("EntityManager.getComponents is deprecated");
-
-    return this.dataset.getAllComponents(entity);
-};
-
-/**
- * @deprecated
- * Retrieves component instance associated with entity
- * @param {Number} entityId
- * @param {Number} componentType
- * @returns {*|undefined} component of specified type or undefined if it was not found
- */
-EntityManager.prototype.getComponentByType = function (entityId, componentType) {
-    console.warn("EntityManager.getComponentByType is deprecated");
-    return this.dataset.getComponentByIndex(entityId, componentType);
-};
-
-/**
- * @deprecated
- * does traversal on a subset of entities which have specified components.
- * @example traverseEntities([Transform,Renderable,Tag],function(transform, renderable, tag, entity){ ... }, this);
- * @param {Array.<class>} classes
- * @param {Function} callback
- * @param {Object} [thisArg] specifies context object on which callbacks are to be called, optional
- */
-EntityManager.prototype.traverseEntities = function (classes, callback, thisArg) {
-    console.warn("EntityManager.traverseEntities is deprecated");
-
-    if (this.dataset === null) {
-        //no data to traverse
-        return;
-    }
-    this.dataset.traverseEntities(classes, callback, thisArg);
-};
-
-/**
- * @deprecated
- * @param entity
- * @param eventName
- * @param listener
- */
-EntityManager.prototype.addEntityEventListener = function (entity, eventName, listener) {
-    console.warn("EntityManager.addEntityEventListener is deprecated");
-    this.dataset.addEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated
- * @param {number} entity
- * @param {string} eventName
- * @param {function} listener
- */
-EntityManager.prototype.removeEntityEventListener = function (entity, eventName, listener) {
-    console.warn("EntityManager.removeEntityEventListener is deprecated");
-    this.dataset.removeEntityEventListener(entity, eventName, listener);
-};
-
-/**
- * @deprecated use dataset directly instead
- * @param entity
- * @param eventName
- * @param event
- */
-EntityManager.prototype.sendEvent = function (entity, eventName, event) {
-    console.warn("EntityManager.sendEvent is deprecated");
-    this.dataset.sendEvent(entity, eventName, event);
-};
-
-/**
- * @deprecated
- * @param {function} klazz
- * @param {function(component: *, entity: number):boolean} callback
- * @param {*} [thisArg]
- * @deprecated
- */
-EntityManager.prototype.traverseComponents = function (klazz, callback, thisArg) {
-    console.warn("EntityManager.traverseComponents is deprecated");
-    if (this.dataset !== null) {
-        this.dataset.traverseComponents(klazz, callback, thisArg);
-    }
-};
-
-/**
- * @deprecated Use {@link #getSystem} instead
- * @template T,C
- * @param {C} klazz
- * @returns {System|T}
- */
-EntityManager.prototype.getOwnerSystemByComponentClass = function (klazz) {
-
-    console.warn("EntityManager.getOwnerSystemByComponentClass is deprecated, use .getSystem instead");
-    const index = this.getOwnerSystemIdByComponentClass(klazz);
-    return this.systems[index];
-};
-
-/**
- * @deprecated
- * @param {function} clazz
- * @returns {number} value >= 0, representing system Id, or -1 if system was not found
- */
-EntityManager.prototype.getOwnerSystemIdByComponentClass = function (clazz) {
-    console.warn("EntityManager.getOwnerSystemIdByComponentClass is deprecated, use .getSystem instead");
-
-    const systems = this.systems;
-    let i = 0;
-    const l = systems.length;
-    for (; i < l; i++) {
-        if (systems[i].componentClass === clazz) {
-            return i;
-        }
-    }
-    return -1;
-};
-
-
-/**
- * same as getComponent when component exists, if component is not associated with the entity, callback will be invoked once when it is added.
- * @param {Number} entityId
- * @param {Class} componentClass
- * @param {function} callback
- * @param {*} [thisArg]
- */
-EntityManager.prototype.getComponentAsync = function (entityId, componentClass, callback, thisArg) {
-    console.warn("EntityManager.getComponentAsync is deprecated");
-
-    const dataset = this.dataset;
-
-    if (dataset === undefined) {
-        throw new Error('No dataset attached');
-    }
-
-    dataset.getComponentAsync(entityId, componentClass, callback, thisArg);
-
-};
-
 export {
     EventType,
     EntityManager

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

@@ -1,6 +1,7 @@
 import { EntityManager } from "./EntityManager.js";
-import { System } from "./System.js";
+import { System, SystemState } from "./System.js";
 import { jest } from '@jest/globals';
+import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
 
 /**
  *
@@ -97,3 +98,63 @@ test("call to 'simulate' propagate to registered system", () => {
             expect(update).toHaveBeenLastCalledWith(7);
         });
 });
+
+
+test("call to 'simulate' ticks fixed update correctly", async () => {
+
+    const dummySystem = new DummySystem();
+    const fixedUpdate = jest.spyOn(dummySystem, 'fixedUpdate');
+
+    const em = await makeEm([dummySystem]);
+
+    em.fixedUpdateStepSize = 1.1;
+
+    em.simulate(3.3001);
+
+    expect(fixedUpdate).toHaveBeenCalledTimes(3);
+    expect(fixedUpdate).toHaveBeenLastCalledWith(1.1);
+});
+
+test("hasSystem", async () => {
+
+    const dummySystem = new DummySystem();
+    const em = await makeEm([]);
+
+    expect(em.hasSystem(DummySystem)).toBe(false);
+
+    await em.addSystem(dummySystem);
+
+    expect(em.hasSystem(DummySystem)).toBe(true);
+});
+
+test("addSystem", async () => {
+    const em = await makeEm([]);
+
+    const s1 = new DummySystem();
+
+    await em.addSystem(s1);
+
+    expect(s1.state.get()).toEqual(SystemState.RUNNING)
+
+    // system is already added, expect silent return
+    expect(() => em.addSystem(s1)).not.toThrow();
+
+    // 2 systems of the same class are not allowed
+    expect(() => em.addSystem(new DummySystem())).toThrow(IllegalStateException);
+});
+
+test("removeSystem", async () => {
+
+    const system = new DummySystem();
+
+    const em = await makeEm([system]);
+
+    expect(await em.removeSystem(system)).toBe(true);
+
+    expect(em.hasSystem(DummySystem)).toBe(false);
+
+    expect(system.state.get()).toEqual(SystemState.STOPPED);
+
+    // Try again, this time we expect nothing to happen
+    expect(await em.removeSystem(system)).toEqual(false);
+});