@woosh/meep-engine 2.50.0 → 2.50.1

package/package.json

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

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

@@ -2,11 +2,11 @@ import { aabb3_build_corners } from "./aabb3_build_corners.js";
 import { aabb_build_frustum } from "./aabb3_build_frustum.js";
 import { aabb3_corner_edge_mapping } from "./aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "./aabb3_edge_corner_mapping.js";
-import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "../plane/plane3_compute_convex_3_plane_intersection.js";
 import { is_point_within_planes } from "../plane/is_point_within_planes.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
-import { plane3_computeLineSegmentIntersection } from "../plane/plane3_computeLineSegmentIntersection.js";
+import { plane3_compute_line_segment_intersection } from "../plane/plane3_compute_line_segment_intersection.js";
 
 /**
  * Common piece of continuous memory for better cache coherence
@@ -205,7 +205,7 @@ export function aabb3_detailed_volume_intersection(
             const nz = planes[plane_address + 2];
             const c = planes[plane_address + 3];
 
-            const edge_intersects = plane3_computeLineSegmentIntersection(
+            const edge_intersects = plane3_compute_line_segment_intersection(
                 scratch_v3_array, 0,
                 corner_0_x, corner_0_y, corner_0_z,
                 corner_1_x, corner_1_y, corner_1_z,
@@ -256,7 +256,7 @@ export function aabb3_detailed_volume_intersection(
             const next_orthogonal_plane_index = (frustum_plane_index + 2) % 4;
             const cp_1 = next_orthogonal_plane_index * 4;
 
-            const intersection_exists = plane_computeConvex3PlaneIntersection(
+            const intersection_exists = plane3_compute_convex_3_plane_intersection(
                 scratch_v3_array, 0,
                 aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
                 planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],

package/src/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -3,9 +3,9 @@ import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import {
-    plane_three_computeConvex3PlaneIntersection
-} from "../plane/plane_three_compute_convex3_plane_intersection.js";
-import { computePlanePlaneIntersection } from "../plane/computePlanePlaneIntersection.js";
+    plane3_three_compute_convex_3_plane_intersection
+} from "../plane/plane3_three_compute_convex_3_plane_intersection.js";
+import { plane3_compute_plane_intersection } from "../plane/plane3_compute_plane_intersection.js";
 
 /**
  *
@@ -82,7 +82,7 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_0 = planes[plane_0_index];
         const plane_1 = planes[plane_1_index];
 
-        const intersection_exists = computePlanePlaneIntersection(plane_0, plane_1, scratch_v3_0, scratch_v3_1);
+        const intersection_exists = plane3_compute_plane_intersection(plane_0, plane_1, scratch_v3_0, scratch_v3_1);
 
         if (!intersection_exists) {
             throw new Error('Planes are parallel and do not intersect, likely an invalid frustum');
@@ -103,7 +103,7 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_1 = planes[plane_1_index];
         const plane_2 = planes[plane_2_index];
 
-        plane_three_computeConvex3PlaneIntersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
+        plane3_three_compute_convex_3_plane_intersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
 
         result.readFromArray(scratch_v3_array, 0)
     }

package/src/core/geom/3d/plane/is_point_within_planes.js

@@ -2,7 +2,7 @@ import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
- *
+ * Checks if point lies in a volume bound by a number of planes, such a camera frustum
  * @param {number} x
  * @param {number} y
  * @param {number} z

package/src/core/geom/3d/plane/lerp_planes_to_array.js

@@ -48,4 +48,6 @@ function lerp_planes_to_array(
     const n_z = a_normal_z * scale_0 + b_normal_z * scale_1;
 
     //compute R
+
+    throw new Error("Not Implemented");
 }

package/src/core/geom/3d/plane/{plane_computeConvex3PlaneIntersection.js → plane3_compute_convex_3_plane_intersection.js}

@@ -23,7 +23,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} c_constant
  * @returns {boolean} true if planes intersect, false otherwise
  */
-export function plane_computeConvex3PlaneIntersection(
+export function plane3_compute_convex_3_plane_intersection(
     result, result_offset,
     a_normal_x, a_normal_y, a_normal_z, a_constant,
     b_normal_x, b_normal_y, b_normal_z, b_constant,

package/src/core/geom/3d/plane/{plane3_computeLineSegmentIntersection.js → plane3_compute_line_segment_intersection.js}

@@ -16,7 +16,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(
+export function plane3_compute_line_segment_intersection(
     result, result_offset,
     x0, y0, z0,
     x1, y1, z1,

package/src/core/geom/3d/plane/{computePlanePlaneIntersection.js → plane3_compute_plane_intersection.js}

@@ -3,21 +3,25 @@
  Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
  section 'Intersection of 2 Planes' and specifically the subsection
  (A) Direct Linear Equation
+ TODO consolidate with {@link plane3_intersect_plane} as they seem to do the same thing
  @param {Plane} p1
  @param {Plane} p2
- @param {Vector3} point
- @param {Vector3} direction
+ @param {Vector3} out_point
+ @param {Vector3} out_direction
  @returns {boolean}
  */
-export function computePlanePlaneIntersection(p1, p2, point, direction) {
+export function plane3_compute_plane_intersection(
+    p1, p2,
+    out_point, out_direction
+) {
 
     // the cross product gives us the direction of the line at the intersection
     // of the two planes, and gives us an easy way to check if the two planes
     // are parallel - the cross product will have zero magnitude
 
-    direction.crossVectors(p1.normal, p2.normal);
+    out_direction.crossVectors(p1.normal, p2.normal);
 
-    const magnitude = direction.lengthSqr();
+    const magnitude = out_direction.lengthSqr();
 
     if (magnitude === 0) {
         return false;
@@ -28,16 +32,16 @@ export function computePlanePlaneIntersection(p1, p2, point, direction) {
     // to set as zero by seeing which has the largest absolute value in the
     // directional vector
 
-    const X = Math.abs(direction.x);
-    const Y = Math.abs(direction.y);
-    const Z = Math.abs(direction.z);
+    const X = Math.abs(out_direction.x);
+    const Y = Math.abs(out_direction.y);
+    const Z = Math.abs(out_direction.z);
 
     if (Z >= X && Z >= Y) {
-        solveIntersectingPoint('z', 'x', 'y', p1, p2, point);
+        solveIntersectingPoint('z', 'x', 'y', p1, p2, out_point);
     } else if (Y >= Z && Y >= X) {
-        solveIntersectingPoint('y', 'z', 'x', p1, p2, point);
+        solveIntersectingPoint('y', 'z', 'x', p1, p2, out_point);
     } else {
-        solveIntersectingPoint('x', 'y', 'z', p1, p2, point);
+        solveIntersectingPoint('x', 'y', 'z', p1, p2, out_point);
     }
 
     return true;

package/src/core/geom/3d/plane/{computePlaneLineIntersection.js → plane3_compute_ray_intersection.js}

@@ -15,7 +15,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist Plane distance
  * @returns {boolean} true if intersection is found, false otherwise
  */
-export function computePlaneLineIntersection(
+export function plane3_compute_ray_intersection(
     out,
     originX, originY, originZ,
     directionX, directionY, directionZ,
@@ -29,6 +29,10 @@ export function computePlaneLineIntersection(
 
         const t = -p / denom;
 
+        if (t < 0) {
+            return false;
+        }
+
         out.set(
             directionX * t + originX,
             directionY * t + originY,

package/src/core/geom/3d/plane/plane3_intersect_plane.js

@@ -3,6 +3,20 @@ import Vector3 from "../../Vector3.js";
 const v0 = new Vector3();
 const v1 = new Vector3();
 
+/**
+ *
+ * @param {Vector3} result_point
+ * @param {Vector3} result_direction
+ * @param {number} a_normal_x
+ * @param {number} a_normal_y
+ * @param {number} a_normal_z
+ * @param {number} a_constant
+ * @param {number} b_normal_x
+ * @param {number} b_normal_y
+ * @param {number} b_normal_z
+ * @param {number} b_constant
+ * @return {boolean}
+ */
 export function plane3_intersect_plane(
     result_point,
     result_direction,

package/src/core/geom/3d/plane/{plane_three_compute_convex3_plane_intersection.js → plane3_three_compute_convex_3_plane_intersection.js}

@@ -1,7 +1,7 @@
-import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "./plane3_compute_convex_3_plane_intersection.js";
 
 /**
- *
+ * Works with THREE.js Plane representations as inputs
  * @param {number[]} result
  * @param {number} result_offset
  * @param {Plane} a
@@ -9,12 +9,15 @@ import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3Pla
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
+export function plane3_three_compute_convex_3_plane_intersection(
+    result, result_offset,
+    a, b, c
+) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
-    return plane_computeConvex3PlaneIntersection(
+    return plane3_compute_convex_3_plane_intersection(
         result,
         result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,

package/src/core/geom/3d/plane/planeRayIntersection.js

@@ -1,4 +1,4 @@
-import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "./plane3_compute_ray_intersection.js";
 
 /**
  *
@@ -10,5 +10,5 @@ import { computePlaneRayIntersection } from "./computePlaneRayIntersection.js";
  * @returns {boolean} true if intersection is found, false otherwise
  */
 export function planeRayIntersection(out, origin, direction, normal, dist) {
-    return computePlaneRayIntersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
+    return plane3_compute_ray_intersection(out, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, normal.x, normal.y, normal.z, dist)
 }

package/src/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -1,7 +1,7 @@
 import { v3_dot } from "../../v3_dot.js";
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
-import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { plane3_compute_convex_3_plane_intersection } from "../plane/plane3_compute_convex_3_plane_intersection.js";
 
 /**
  * Planes used to bound the simplex
@@ -152,25 +152,25 @@ export function compute_bounding_simplex_3d(
     min_d -= padding;
 
     // let's compute intersection points for each tri-plane combination to find simplex corners
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 3,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 6,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
         SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
     );
-    plane_computeConvex3PlaneIntersection(
+    plane3_compute_convex_3_plane_intersection(
         result, result_offset + 9,
         SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,

package/src/core/geom/Vector3.d.ts

@@ -69,14 +69,16 @@ export default class Vector3 implements Vector3Like {
 
     clone(): Vector3
 
-    equals(other:Vector3Like):boolean
+    equals(other: Vector3Like): boolean
 
-    roughlyEquals(other:Vector3Like,tolerance?:number):boolean
+    roughlyEquals(other: Vector3Like, tolerance?: number): boolean
 
     normalize(): void
 
     length(): number
 
+    lengthSqr(): number
+
     lerpVectors(a: Vector3Like, b: Vector3Like, fraction: number): void
 
     distanceTo(other: Vector3Like): number

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

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);
+});

package/src/engine/ecs/System.js

@@ -155,13 +155,19 @@ Object.defineProperties(System.prototype, {
  * @readonly
  * @enum {number}
  */
-System.State = {
+export const SystemState = {
     INITIAL: 0,
     STARTING: 1,
     RUNNING: 2,
     STOPPING: 3,
     STOPPED: 4
-};
+}
+
+/**
+ * @readonly
+ * @deprecated use {@link SystemState} directly instead
+ */
+System.State = SystemState;
 
 /**
  *

package/src/engine/graphics/ecs/camera/Camera.js

@@ -14,7 +14,7 @@ import { frustum_from_camera } from "./frustum_from_camera.js";
 import { invertQuaternionOrientation } from "./InvertQuaternionOrientation.js";
 import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 import { ProjectionType } from "./ProjectionType.js";
-import { computePlaneRayIntersection } from "../../../../core/geom/3d/plane/computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "../../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
 
 /**
  * @class
@@ -250,7 +250,7 @@ export class Camera {
 
         assert.defined(plane, 'plane');
 
-        computePlaneRayIntersection(
+        plane3_compute_ray_intersection(
             out,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_z,

package/src/engine/graphics/ecs/path/entity/EntityPath.js

@@ -86,7 +86,7 @@ export class EntityPath {
         const blueprint = def.blueprint;
 
         marker.offset = offset;
-        marker.entity = blueprint.buildEntityBuilder({});
+        marker.entity = blueprint.build({});
         marker.definition = def;
 
         this.__position_marker(marker);

package/src/engine/graphics/render/forward_plus/computeFrustumCorners.js

@@ -1,6 +1,6 @@
 import {
-    plane_three_computeConvex3PlaneIntersection
-} from "../../../../core/geom/3d/plane/plane_three_compute_convex3_plane_intersection.js";
+    plane3_three_compute_convex_3_plane_intersection
+} from "../../../../core/geom/3d/plane/plane3_three_compute_convex_3_plane_intersection.js";
 
 /**
  * Get frustum corners from a set of planes
@@ -13,7 +13,7 @@ export function computeFrustumCorners(result, planes) {
     const plane_y0 = planes[2];
     const plane_z0 = planes[4];
 
-    plane_three_computeConvex3PlaneIntersection(result, 0,
+    plane3_three_compute_convex_3_plane_intersection(result, 0,
         plane_x0,
         plane_y0,
         plane_z0
@@ -21,7 +21,7 @@ export function computeFrustumCorners(result, planes) {
 
     const plane_z1 = planes[5];
 
-    plane_three_computeConvex3PlaneIntersection(result, 3,
+    plane3_three_compute_convex_3_plane_intersection(result, 3,
         plane_x0,
         plane_y0,
         plane_z1
@@ -29,13 +29,13 @@ export function computeFrustumCorners(result, planes) {
 
     const plane_y1 = planes[3];
 
-    plane_three_computeConvex3PlaneIntersection(result, 6,
+    plane3_three_compute_convex_3_plane_intersection(result, 6,
         plane_x0,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(result, 9,
+    plane3_three_compute_convex_3_plane_intersection(result, 9,
         plane_x0,
         plane_y1,
         plane_z1
@@ -43,25 +43,25 @@ export function computeFrustumCorners(result, planes) {
 
     const plane_x1 = planes[1];
 
-    plane_three_computeConvex3PlaneIntersection(result, 12,
+    plane3_three_compute_convex_3_plane_intersection(result, 12,
         plane_x1,
         plane_y0,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(result, 15,
+    plane3_three_compute_convex_3_plane_intersection(result, 15,
         plane_x1,
         plane_y0,
         plane_z1
     );
 
-    plane_three_computeConvex3PlaneIntersection(result, 18,
+    plane3_three_compute_convex_3_plane_intersection(result, 18,
         plane_x1,
         plane_y1,
         plane_z0
     );
 
-    plane_three_computeConvex3PlaneIntersection(result, 21,
+    plane3_three_compute_convex_3_plane_intersection(result, 21,
         plane_x1,
         plane_y1,
         plane_z1

package/src/engine/graphics/render/layers/RenderLayerUtils.js

@@ -1,7 +1,7 @@
 import { v3_distance_above_plane } from "../../../../core/geom/v3_distance_above_plane.js";
 import {
-    plane_three_computeConvex3PlaneIntersection
-} from "../../../../core/geom/3d/plane/plane_three_compute_convex3_plane_intersection.js";
+    plane3_three_compute_convex_3_plane_intersection
+} from "../../../../core/geom/3d/plane/plane3_three_compute_convex_3_plane_intersection.js";
 
 /**
  *
@@ -43,7 +43,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
             const p0 = pair[0];
             const p1 = pair[1];
 
-            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, 0, p0, p1, objectPlane);
+            const planeIntersection = plane3_three_compute_convex_3_plane_intersection(p, 0, p0, p1, objectPlane);
 
             if (!planeIntersection) {
                 //no intersection

package/src/engine/intelligence/behavior/primitive/SucceedingBehavior.js

@@ -20,7 +20,7 @@ export class SucceedingBehavior extends Behavior {
     }
 
     /**
-     *
+     * @deprecated use static INSTANCE instead
      * @param {number} delayTicks
      * @return {SucceedingBehavior}
      */

package/src/engine/scene/SceneManager.spec.js

@@ -85,6 +85,7 @@ test("set active scene", () => {
     manager.set('x');
 
     expect(manager.current_scene).toBe(scene);
+    expect(scene.active.getValue()).toBe(true);
     expect(entityManager.dataset).toBe(scene.dataset);
 });
 
@@ -105,3 +106,26 @@ test("stack push/pop", () => {
 
     expect(manager.current_scene).toBe(scene_x);
 });
+
+test("clear on empty does nothing", () => {
+    const { manager } = makeSM();
+
+    manager.clear();
+
+    expect(manager.current_scene).toBeNull();
+});
+
+test("clear correctly clears active scene", () => {
+
+    const { manager, entityManager } = makeSM();
+
+    const scene = manager.create('x');
+
+    manager.set('x');
+
+    manager.clear();
+
+    expect(manager.current_scene).toBeNull();
+    expect(scene.active.getValue()).toBe(false);
+    expect(entityManager.dataset).toBe(null);
+});

package/src/generation/grid/GridData.js

@@ -3,7 +3,6 @@ import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
 import { max2 } from "../../core/math/max2.js";
 import { qt_collect_by_circle } from "../../core/geom/2d/quad-tree/qt_collect_by_circle.js";
-import { v2_length_sqr } from "../../core/geom/Vector2.js";
 
 /**
  *
@@ -122,7 +121,14 @@ export class GridData {
             const distance_limit_sqr = distance_limit * distance_limit;
 
             // check refined containment
-            if (v2_length_sqr(x - marker.position.x, y - marker.position.y) > distance_limit_sqr) {
+            const position = marker.position;
+
+            const dx = x - position.x;
+            const dy = y - position.y;
+
+            const distance_sqr = dx * dx + dy * dy;
+
+            if (distance_sqr > distance_limit_sqr) {
                 continue;
             }
 

package/src/generation/grid/GridData.spec.js

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

package/src/generation/markers/actions/MarkerNodeActionEntityPlacement.js

@@ -64,7 +64,7 @@ export class MarkerNodeActionEntityPlacement extends MarkerNodeAction {
     execute(grid, ecd, node) {
         const blueprint = this.entity;
 
-        const entityBuilder = blueprint.buildEntityBuilder(node.properties);
+        const entityBuilder = blueprint.build(node.properties);
 
         // execute post-process step
         if (this.processor !== null) {

package/src/view/minimap/dom/MinimapCameraView.js

@@ -3,7 +3,7 @@ import Vector3 from "../../../core/geom/Vector3.js";
 import ObservedValue from "../../../core/model/ObservedValue.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import SVG from "../../SVG.js";
-import { computePlaneRayIntersection } from "../../../core/geom/3d/plane/computePlaneRayIntersection.js";
+import { plane3_compute_ray_intersection } from "../../../core/geom/3d/plane/plane3_compute_ray_intersection.js";
 
 
 const rayContact = new SurfacePoint3();
@@ -93,7 +93,7 @@ export class MinimapCameraView extends View {
         const JITTER = 0.00001;
 
         if (terrain === null) {
-            computePlaneRayIntersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
+            plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
         } else {
 
             let oX = originX;
@@ -118,7 +118,7 @@ export class MinimapCameraView extends View {
 
             if (!foundHit) {
                 //no hit found, fall back to planar test
-                computePlaneRayIntersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
+                plane3_compute_ray_intersection(result, originX, originY, originZ, directionX, directionY, directionZ, 0, 1, 0, 0);
             }
 
         }

package/src/core/geom/3d/plane/computePlaneRayIntersection.js

@@ -1,55 +0,0 @@
-import { v3_dot } from "../../v3_dot.js";
-
-/**
- *
- * @param {Vector3} out Result will be written here
- * @param {number} originX Ray origin
- * @param {number} originY Ray origin
- * @param {number} originZ Ray origin
- * @param {number} directionX Ray direction
- * @param {number} directionY Ray direction
- * @param {number} directionZ Ray direction
- * @param {number} normalX Plane normal
- * @param {number} normalY Plane normal
- * @param {number} normalZ Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
- */
-export function computePlaneRayIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
-
-    if (denom !== 0) {
-
-        const t = -p / denom;
-
-        if (t < 0) {
-            return false;
-        }
-
-        out.set(
-            directionX * t + originX,
-            directionY * t + originY,
-            directionZ * t + originZ
-        );
-
-        return true;
-
-    } else {
-
-        if (p === 0) {
-
-            out.set(originX, originY, originZ);
-
-            return true;
-
-        } else {
-
-            //no intersection
-            return false;
-
-        }
-
-    }
-}

package/src/generation/grid/MarkerMatchCounter.js

@@ -1,25 +0,0 @@
-export class MarkerMatchCounter {
-    /**
-     * @template T
-     */
-    constructor() {
-        /**
-         * Predicate
-         * @type {MarkerNodeMatcher|null}
-         */
-        this.matcher = null;
-        this.count = 0;
-    }
-
-    /**
-     *
-     * @param {QuadTreeDatum<MarkerNode>} node
-     */
-    exec(node) {
-        const marker = node.data;
-
-        if (this.matcher.match(marker)) {
-            this.count++;
-        }
-    }
-}