@woosh/meep-engine 2.48.17 → 2.48.19

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"
             ;
     }
 

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

@@ -1,19 +1,15 @@
 import { GUID } from "./GUID.js";
 
 test("uniqueness out of 2", () => {
-    const a = new GUID();
-    const b = new GUID();
+    const a = GUID.v1();
+    const b = GUID.v1();
 
     expect(a.equals(b)).toBe(false);
 });
 
-
 test("equality", () => {
-    const a = new GUID();
-    const b = new GUID();
-
-    a.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
-    b.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+    const a = GUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+    const b = GUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
 
     expect(a.equals(b)).toBe(true);
 
@@ -28,10 +24,24 @@ test("hash stability", () => {
     expect(guid.hash()).toBe(guid.hash());
 });
 
+test("copy", () => {
+    const a = GUID.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+    const a_string = a.toString();
+
+    const b = GUID.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
+
+    expect(a.equals(b)).toBe(false);
+
+    b.copy(a);
+
+    expect(a.equals(b)).toBe(true);
+
+    // make sure that "a" is not changed
+    expect(a.toString()).toEqual(a_string);
+});
 
 test("to/from JSON consistency", () => {
-    const a = new GUID();
-    a.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
+    const a = GUID.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
 
     const b = new GUID();
 
@@ -39,3 +49,39 @@ test("to/from JSON consistency", () => {
 
     expect(b.equals(a)).toBe(true)
 });
+
+test(".data setter performs a copy instead of assignment", () => {
+    const id = new GUID();
+
+    const data = new Uint8Array(16);
+
+    id.data = data;
+
+    expect(id.data).not.toBe(data);
+});
+
+test(".data set/get", () => {
+    const a = new GUID();
+
+    const sample_0 = [
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF, 0xFF, 0xFF, 0xFF,
+    ];
+
+    a.data = sample_0;
+
+    expect(Array.from(a.data)).toEqual(sample_0);
+
+    const sample_1 = [
+        0x00, 0x01, 0x02, 0x03,
+        0x04, 0x05, 0x06, 0x07,
+        0x08, 0x09, 0x0A, 0x0B,
+        0x0C, 0x0D, 0x0E, 0x0F,
+    ];
+
+    a.data = sample_1;
+
+    expect(Array.from(a.data)).toEqual(sample_1);
+});

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

@@ -1,6 +1,6 @@
 import { max2 } from "../../../core/math/max2.js";
 import { Voice } from "./Voice.js";
-import EntityBuilder, { EntityBuilderFlags } from "../EntityBuilder.js";
+import EntityBuilder from "../EntityBuilder.js";
 import GUIElement from "../gui/GUIElement.js";
 import { SerializationMetadata } from "../components/SerializationMetadata.js";
 import HeadsUpDisplay from "../gui/hud/HeadsUpDisplay.js";
@@ -32,6 +32,7 @@ import { globalMetrics } from "../../metrics/GlobalMetrics.js";
 import { MetricsCategory } from "../../metrics/MetricsCategory.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import { EntityBuilderFlags } from "../EntityBuilderFlags.js";
 
 /**
  * Delay before the user notices the text and begins to read

package/src/engine/ecs/transform/Transform.d.ts

@@ -6,7 +6,7 @@ export class Transform {
     public readonly rotation: Quaternion
     public readonly scale: Vector3
 
-    public readonly matrix:ArrayLike<number>
+    public readonly matrix: ArrayLike<number>
 
     public lookAt(target: Vector3): void
 
@@ -22,6 +22,8 @@ export class Transform {
         rotation?: { x: number, y: number, z: number, w: number },
     }): void
 
+    toJSON(): any
+
     copy(other: Transform): void
 
     clone(): Transform
@@ -37,4 +39,12 @@ export class Transform {
     multiplyTransforms(a: Transform, b: Transform): void
 
     makeIdentity(): void
+
+    setFlag(flag: number): void
+
+    getFlag(flag: number): boolean
+
+    clearFlag(flag: number): void
+
+    writeFlag(flag: number, value: boolean): void
 }

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

@@ -10,6 +10,7 @@ import { TransformFlags } from "./TransformFlags.js";
 import { allocate_transform_m4 } from "../../graphics/ecs/mesh-v2/allocate_transform_m4.js";
 import { assert } from "../../../core/assert.js";
 import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
+import { MATRIX_4_IDENTITY } from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 
 /**
  *
@@ -315,9 +316,11 @@ export class Transform {
      *      - scale:    [1,1,1]
      */
     makeIdentity() {
-        this.position.copy(Vector3.zero);
-        this.rotation.copy(Quaternion.identity);
-        this.scale.copy(Vector3.one);
+        this.fromMatrix4(MATRIX_4_IDENTITY);
+    }
+
+    toString() {
+        return `{ position: ${this.position}, rotation: ${this.rotation}, scale: ${this.scale} }`;
     }
 }