@woosh/meep-engine 2.48.16 → 2.48.18

package/src/core/geom/Vector3.js

@@ -38,7 +38,7 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset=0) {
+    readFromArray(array, offset = 0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -51,16 +51,16 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset=0) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;
     }
 
-    asArray(){
+    asArray() {
         const r = [];
 
-        this.writeToArray(r,0);
+        this.writeToArray(r, 0);
 
         return r;
     }
@@ -171,12 +171,12 @@ class Vector3 {
      * @param {Vector3} a
      * @param {Vector3} b
      */
-    addVectors(a,b){
+    addVectors(a, b) {
         const x = a.x + b.x;
         const y = a.y + b.y;
         const z = a.z + b.z;
 
-        this.set(x,y,z);
+        this.set(x, y, z);
     }
 
     /**
@@ -378,7 +378,7 @@ class Vector3 {
      * @returns {number}
      */
     length() {
-        return v3Length(this);
+        return v3_length(this.x, this.y, this.z);
     }
 
     /**
@@ -532,7 +532,7 @@ class Vector3 {
      * @param {number} fraction
      */
     lerpVectors(a, b, fraction) {
-        v3Lerp(this, a, b, fraction);
+        v3_lerp(this, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
     }
 
     /**
@@ -806,7 +806,7 @@ class Vector3 {
     }
 
     toString() {
-        return `[x:${this.x}, y:${this.y}, z:${this.z}]`;
+        return `{ x:${this.x}, y:${this.y}, z:${this.z} }`;
     }
 
     /**
@@ -1095,7 +1095,6 @@ Vector3.back = Object.freeze(new Vector3(0, 0, -1));
 
 Vector3.typeName = "Vector3";
 
-
 /**
  *
  * @param {number} x0
@@ -1109,25 +1108,4 @@ Vector3.typeName = "Vector3";
 Vector3._dot = v3_dot;
 
 
-/**
- *
- * @param {{x:number, y:number, z:number}} v
- * @return {number}
- */
-function v3Length(v) {
-    return v3_length(v.x, v.y, v.z);
-}
-
-
-/**
- *
- * @param {Vector3} result
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {number} fraction
- */
-function v3Lerp(result, a, b, fraction) {
-    v3_lerp(result, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
-}
-
 export default Vector3;

package/src/core/math/fract.spec.js

@@ -0,0 +1,11 @@
+import { fract } from "./fract.js";
+
+test("correctness", () => {
+
+    expect(fract(0)).toBeCloseTo(0);
+    expect(fract(0.1)).toBeCloseTo(0.1);
+    expect(fract(-0.1)).toBeCloseTo(-0.1);
+    expect(fract(1.1)).toBeCloseTo(0.1);
+    expect(fract(-1.1)).toBeCloseTo(-0.1);
+
+});

package/src/core/math/isPowerOfTwo.spec.js

@@ -0,0 +1,9 @@
+import { isPowerOfTwo } from "./isPowerOrTwo.js";
+
+test("correctness", () => {
+    expect(isPowerOfTwo(1)).toBe(true);
+    expect(isPowerOfTwo(2)).toBe(true);
+    expect(isPowerOfTwo(3)).toBe(false);
+    expect(isPowerOfTwo(4)).toBe(true);
+    expect(isPowerOfTwo(5)).toBe(false);
+});

package/src/core/math/isPowerOrTwo.js

@@ -1,10 +1,15 @@
+import { assert } from "../assert.js";
+
 /**
  * Is the number a power of two?
  * e.g. 2,4,8,16 etc.
+ * NOTE: only valid for non-negative integers
  * @param {number} value
  * @returns {boolean}
  */
 export function isPowerOfTwo(value) {
+    assert.isNonNegativeInteger(value, 'value');
+
 
     return (value & (value - 1)) === 0 && value !== 0;
 

package/src/core/math/newton_solver_1d.js

@@ -2,7 +2,7 @@
  * Newtonian solver, works by moving along the curve in the direction of gradient
  * @template T
  * @param {function(T):number} f
- * @param {T} xStart
+ * @param {number} xStart
  * @param {number} [max_steps]
  * @param {number} [eps]
  * @returns {number}

package/src/core/math/newton_solver_1d.spec.js

@@ -0,0 +1,9 @@
+import { newton_solver_1d } from "./newton_solver_1d.js";
+
+test("solve for line", () => {
+    expect(newton_solver_1d((x) => x * 2 + 5, 1))
+        .toBeCloseTo(-2.5);
+
+    expect(newton_solver_1d((x) => -x * 7 - 3, 1))
+        .toBeCloseTo(-0.429);
+});

package/src/core/math/pingpong.spec.js

@@ -0,0 +1,11 @@
+import { pingpong } from "./pingpong.js";
+
+test("correctness", () => {
+
+    expect(pingpong(0, 1)).toBe(0);
+    expect(pingpong(0.1, 1)).toBeCloseTo(0.1);
+    expect(pingpong(1, 1)).toBe(1);
+    expect(pingpong(1.1, 1)).toBeCloseTo(0.9);
+    expect(pingpong(2.1, 1)).toBeCloseTo(0.1);
+
+});

package/src/core/math/random/randomBytes.js

@@ -0,0 +1,16 @@
+import { randomUint8 } from "./randomUint8.js";
+
+/**
+ *
+ * @param {Uint8Array} result
+ * @param {number} result_offset
+ * @param {function():number} random
+ * @param {number} count
+ */
+export function randomBytes(result, result_offset, random, count) {
+    for (let i = 0; i < count; i++) {
+
+        result[result_offset + i] = randomUint8(random);
+
+    }
+}

package/src/core/math/random/randomFloatBetween.spec.js

@@ -0,0 +1,8 @@
+import { returnOne, returnZero } from "../../function/Functions.js";
+import { randomFloatBetween } from "./randomFloatBetween.js";
+
+test("limits", () => {
+
+    expect(randomFloatBetween(returnZero, -3.11, 7.23)).toEqual(-3.11);
+    expect(randomFloatBetween(returnOne, -3.11, 7.23)).toEqual(7.23);
+})

package/src/core/math/random/randomFromArray.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { min2 } from "../min2.js";
+import { randomIntegerBetween } from "./randomIntegerBetween.js";
 
 /**
  * @template T
@@ -13,7 +13,7 @@ export function randomFromArray(random, array) {
 
     const length = array.length;
 
-    const i = min2(length - 1, Math.floor(random() * length));
+    const index = randomIntegerBetween(random, 0, length - 1);
 
-    return array[i];
+    return array[index];
 }

package/src/core/math/random/randomIntegerBetween.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * Inclusive random between two boundaries, result is integer
  * @param {function} random
@@ -6,6 +8,9 @@
  * @returns {number}
  */
 export function randomIntegerBetween(random, min, max) {
+    assert.isInteger(min, 'min');
+    assert.isInteger(max, 'max');
+
     const span = max - min;
 
     const roll = random();

package/src/core/math/random/randomIntegerBetween.spec.js

@@ -0,0 +1,7 @@
+import { randomIntegerBetween } from "./randomIntegerBetween.js";
+import { returnOne, returnZero } from "../../function/Functions.js";
+
+test("limits", () => {
+    expect(randomIntegerBetween(returnZero, -3, 7)).toEqual(-3);
+    expect(randomIntegerBetween(returnOne, -3, 7)).toEqual(7);
+});

package/src/core/math/statistics/halton_sequence.spec.js

@@ -0,0 +1,17 @@
+import { halton_sequence } from "./halton_sequence.js";
+
+test("unique values in base 10", () => {
+
+    const values = [];
+
+    for (let i = 0; i < 10; i++) {
+        values.push(halton_sequence(10, i));
+    }
+
+    values.sort();
+
+    for (let i = 1; i < 10; i++) {
+        expect(values[i]).not.toEqual(values[i - 1]);
+    }
+
+});

package/src/engine/asset/AssetManager.d.ts

@@ -13,6 +13,14 @@ interface AssetManagerOptions<CTX> {
     executor?: ConcurrentExecutor
 }
 
+interface GetOptions<T> {
+    type: string
+    path: string
+    callback: (asset: Asset<T>) => any
+    failure: (reason: any) => any
+    progress: (current: number, total: number) => any
+}
+
 export declare class AssetManager<CTX> {
     constructor(options?: AssetManagerOptions<CTX>)
 
@@ -24,13 +32,15 @@ export declare class AssetManager<CTX> {
 
     shutdown(immediate?: boolean): Promise<void>
 
+    get<T>(options: GetOptions<T>): void
+
     promise<T>(path: string, type: string, options?: PromiseOptions): Promise<Asset<T>>
 
     remove(path: string, type: string): boolean
 
     clear(): void
 
-    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T,CTX>>
+    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T, CTX>>
 
     unregisterLoader(type: string): Promise<void>
 

package/src/engine/asset/AssetManager.spec.js

@@ -16,7 +16,7 @@ function dummyEngine() {
 }
 
 class DummyLoader extends AssetLoader {
-    load(scope,path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
         success(new Asset(() => 1));
     }
 }
@@ -29,7 +29,7 @@ test('successful get', async () => {
     am.startup();
 
     return new Promise(function (resolve, reject) {
-        am.get('bla', 'a', resolve, reject);
+        am.get({ path: 'bla', type: 'a', callback: resolve, failure: reject });
     });
 });
 

package/src/engine/control/ControlContext.js

@@ -1,7 +1,8 @@
-import EntityBuilder, { EntityBuilderFlags } from "../ecs/EntityBuilder.js";
+import EntityBuilder from "../ecs/EntityBuilder.js";
 import { ControlContextState } from "./ControlContextState.js";
 import { IllegalStateException } from "../../core/fsm/exceptions/IllegalStateException.js";
 import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
+import { EntityBuilderFlags } from "../ecs/EntityBuilderFlags.js";
 
 export class ControlContext {
     constructor() {

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

@@ -11,6 +11,8 @@ export default class EntityBuilder {
 
     removeComponent<T>(componentType: Type<T>): T | null
 
+    removeAllComponents(): void
+
     getComponent<T>(componentType: Type<T>): T | null
 
     getComponentSafe<T>(componentType: Type<T>): T
@@ -30,4 +32,8 @@ export default class EntityBuilder {
     removeEventListener(eventName: string, listener: (data?: any) => void, context?: any): EntityBuilder
 
     static readFromDataset(entity: number, dataset: EntityComponentDataset): EntityBuilder
+
+    getFlag(flag: number): boolean
+
+    setFlag(flag: number, value: number): void
 }

package/src/engine/ecs/EntityBuilder.js

@@ -2,27 +2,7 @@ import Signal from "../../core/events/signal/Signal.js";
 import { assert } from "../../core/assert.js";
 import { EventType } from "./EntityManager.js";
 import { isDefined } from "../../core/process/matcher/Matchers.js";
-
-/**
- *
- * @enum
- */
-export const EntityBuilderFlags = {
-    /**
-     * Whether the entity is built, set internally
-     */
-    Built: 1,
-    /**
-     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link #build} - will register the component first
-     */
-    RegisterComponents: 2,
-    /**
-     * Entity builder will watch destruction of the entity (subscribe to event), this will make the EntityBuilder automatically
-     * recognize when the corresponding entity is destroyed outside the EntityBuilder API
-     * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the EntityBuilder
-     */
-    WatchDestruction: 4
-};
+import { EntityBuilderFlags } from "./EntityBuilderFlags.js";
 
 /**
  * Set of default flags
@@ -152,7 +132,7 @@ class EntityBuilder {
      */
     add(componentInstance) {
         if (componentInstance === undefined) {
-            throw new Error("Can not add " + componentInstance + " to EntityBuilder");
+            throw new Error(`Can not add ${componentInstance} to EntityBuilder`);
         }
 
         assert.notOk(this.hasComponent(Object.getPrototypeOf(componentInstance).constructor), 'Component of this type already exists');

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

@@ -1,5 +1,6 @@
-import EntityBuilder, { EntityBuilderFlags } from "./EntityBuilder.js";
+import EntityBuilder from "./EntityBuilder.js";
 import { EntityComponentDataset } from "./EntityComponentDataset.js";
+import { EntityBuilderFlags } from "./EntityBuilderFlags.js";
 
 
 class DummyComponent {
@@ -62,3 +63,72 @@ test("'Built' flag is reset when entity is removed without invoking 'destroy' me
 
     expect(b.getFlag(EntityBuilderFlags.Built)).toBe(false);
 });
+
+test("removeAllComponents from empty", () => {
+    const entity = new EntityBuilder();
+
+    expect(() => entity.removeAllComponents()).not.toThrow()
+});
+
+test("removeAllComponents with 1 entity", () => {
+    const entity = new EntityBuilder();
+
+    entity.add(new DummyComponent());
+
+    expect(entity.hasComponent(DummyComponent)).toBe(true);
+
+    entity.removeAllComponents();
+
+    expect(entity.hasComponent(DummyComponent)).toBe(false);
+});
+
+test("removeComponent when component is not preset", () => {
+    const entity = new EntityBuilder();
+
+    expect(entity.removeComponent(DummyComponent)).toBe(null);
+});
+
+test("removeComponent when component is preset", () => {
+    const entity = new EntityBuilder();
+
+    const component = new DummyComponent();
+
+    entity.add(component)
+
+    expect(entity.removeComponent(DummyComponent)).toBe(component);
+
+    expect(entity.hasComponent(DummyComponent)).toBe(false);
+});
+
+test("getComponentSafe throws when component is missing", () => {
+
+    const entity = new EntityBuilder();
+
+    expect(() => entity.getComponentSafe(DummyComponent)).toThrow();
+
+});
+test("getComponentSafe throws when component is present", () => {
+
+    const entity = new EntityBuilder();
+
+    const component = new DummyComponent();
+    entity.add(component);
+
+    expect(() => entity.getComponentSafe(DummyComponent)).not.toThrow();
+
+    expect(entity.getComponentSafe(DummyComponent)).toBe(component);
+});
+
+test("adding component to live entity results in component being added to the dataset", () => {
+
+    const entity = new EntityBuilder();
+
+    const ecd = sampleDataset();
+
+    entity.build(ecd)
+
+    const component = new DummyComponent();
+    entity.add(component);
+
+    expect(ecd.getComponent(entity.entity, DummyComponent)).toBe(component);
+});

package/src/engine/ecs/EntityBuilderFlags.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @enum
+ */
+export const EntityBuilderFlags = {
+    /**
+     * Whether the entity is built, set internally
+     */
+    Built: 1,
+    /**
+     * If component type is not registered on the {@link EntityComponentDataset} when calling {@link #build} - will register the component first
+     */
+    RegisterComponents: 2,
+    /**
+     * Entity builder will watch destruction of the entity (subscribe to event), this will make the EntityBuilder automatically
+     * recognize when the corresponding entity is destroyed outside the EntityBuilder API
+     * NOTE: useful to turn off to save a bit of memory, as those event listeners take up a bit of space. Feel free to turn this flag off when you don't care to keep the reference to the EntityBuilder
+     */
+    WatchDestruction: 4
+};

package/src/engine/ecs/EntityComponentDataset.js

@@ -1071,7 +1071,7 @@ export class EntityComponentDataset {
      * @param {function} callback
      * @param {*} [thisArg]
      */
-    getComponentAsync (entityId, componentClass, callback, thisArg) {
+    getComponentAsync(entityId, componentClass, callback, thisArg) {
         const component = this.getComponent(entityId, componentClass);
 
         const handler = (options) => {
@@ -1274,11 +1274,8 @@ export class EntityComponentDataset {
      */
     traverseComponentsByIndex(componentTypeIndex, visitor, thisArg) {
 
-        if (!ENV_PRODUCTION) {
-            assert.isNumber(componentTypeIndex, "componentTypeIndex");
-            assert.isFunction(visitor, "visitor");
-        }
-
+        assert.isNumber(componentTypeIndex, "componentTypeIndex");
+        assert.isFunction(visitor, "visitor");
 
         this.__traverseComponentsByIndex_via_property(componentTypeIndex, visitor, thisArg);
     }

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -5,7 +5,7 @@ import { DataScope } from "../../../../../model/game/unit/actions/data/DataScope
 import { Blackboard } from "../../intelligence/blackboard/Blackboard.js";
 import { compareNumbersDescending, returnTrue } from "../../../core/function/Functions.js";
 import { EntityProxyScope } from "../binding/EntityProxyScope.js";
-import EntityBuilder, { EntityBuilderFlags } from "../EntityBuilder.js";
+import EntityBuilder from "../EntityBuilder.js";
 import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorComponent.js";
 import { SequenceBehavior } from "../../intelligence/behavior/composite/SequenceBehavior.js";
 import { DieBehavior } from "../../intelligence/behavior/ecs/DieBehavior.js";
@@ -22,6 +22,7 @@ import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween
 import { randomMultipleFromArray } from "../../../core/collection/array/randomMultipleFromArray.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import { EntityBuilderFlags } from "../EntityBuilderFlags.js";
 
 /**
  * In seconds

package/src/engine/ecs/gui/menu/radial/RadialContextMenu.js

@@ -3,7 +3,7 @@
  */
 import { SerializationMetadata } from "../../../components/SerializationMetadata.js";
 
-import EntityBuilder, { EntityBuilderFlags } from "../../../EntityBuilder.js";
+import EntityBuilder from "../../../EntityBuilder.js";
 import GUIElement from "../../GUIElement.js";
 import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
 import { TouchEvents } from "../../../../input/devices/events/TouchEvents.js";
@@ -12,6 +12,7 @@ import RadialMenuView from "../../../../../view/elements/radial/RadialMenu.js";
 import { animateAppearance } from "./AnimateAppearance.js";
 import { animateDisappearance } from "./AnimateDisappearance.js";
 import { RadialMenuSettings } from "./RadialMenuSettings.js";
+import { EntityBuilderFlags } from "../../../EntityBuilderFlags.js";
 
 /**
  *

package/src/engine/ecs/guid/GUID.js

@@ -1,8 +1,9 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { randomUint8 } from "../../../core/math/random/randomUint8.js";
-import { is_typed_array_equals } from "../../../core/collection/array/typed/is_typed_array_equals.js";
 import { dec2hex } from "../../../core/binary/dec2hex.js";
 import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { randomBytes } from "../../../core/math/random/randomBytes.js";
+import { assert } from "../../../core/assert.js";
 
 // Previous uuid creation time
 let _lastMSecs = 0;
@@ -10,23 +11,8 @@ let _lastNSecs = 0;
 
 const random = seededRandom(Date.now());
 
-/**
- *
- * @param {Uint8Array} result
- * @param {number} result_offset
- * @param {function():number} random
- * @param {number} count
- */
-function randomBytes(result, result_offset, random, count) {
-    for (let i = 0; i < count; i++) {
-
-        result[result_offset + i] = randomUint8(random);
-
-    }
-}
-
 // node and clockseq need to be initialized to random values.
-let _nodeId = new Uint8Array(6);
+const _nodeId = new Uint8Array(6);
 
 // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
 randomBytes(_nodeId, 0, random, 6);
@@ -41,15 +27,14 @@ let _clockseq = ((randomUint8(random) << 8) | randomUint8(random)) & 0x3fff;
 export class GUID {
     #data = new Uint8Array(16);
 
-    constructor() {
-        this.v1();
-    }
-
     /**
      *
      * @param {number[]|Uint8Array|ArrayLike<number>} bytes
      */
     set data(bytes) {
+        assert.isArrayLike(bytes, 'bytes');
+        assert.greaterThanOrEqual(bytes.length, 16, 'bytes.length >= 16');
+
         array_copy(bytes, 0, this.#data, 0, 16);
     }
 
@@ -136,12 +121,27 @@ export class GUID {
         }
     }
 
+    /**
+     *
+     * @return {GUID}
+     */
+    static v1() {
+        const uuid = new GUID();
+
+        uuid.v1();
+
+        return uuid;
+    }
+
     /***
      * String in UUID format
      * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/parse.js#L3
      * @param {string} string
      */
     parse(string) {
+        assert.isString(string, 'string');
+        assert.greaterThanOrEqual(string.length, 36, 'string.length');
+
         let v;
         const arr = this.#data;
 
@@ -173,6 +173,19 @@ export class GUID {
         arr[15] = v & 0xff;
     }
 
+    /**
+     *
+     * @param {string} string
+     * @return {GUID}
+     */
+    static parse(string) {
+        const r = new GUID();
+
+        r.parse(string);
+
+        return r;
+    }
+
     /**
      * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/stringify.js#L16
      * @returns {string}
@@ -218,7 +231,16 @@ export class GUID {
      * @returns {boolean}
      */
     equals(other) {
-        return is_typed_array_equals(this.#data, other.#data);
+        const this_data = this.#data;
+        const other_data = other.#data;
+
+        for (let i = 0; i < 16; i++) {
+            if (this_data[i] !== other_data[i]) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
@@ -228,10 +250,10 @@ export class GUID {
         const data = this.#data;
 
         // use some non-metadata bytes as a hash
-        return data[0]
-            | data[1] << 8
-            | data[2] << 16
-            | data[3] << 24
+        return data[3] // low byte of "time_low", very likely to differ between two UUIDs
+            | data[5] << 8 // low byte of "time_mid"
+            | data[9] << 16 // "clock_seq_low"
+            | data[15] << 24 // low byte of "node"
             ;
     }