@woosh/meep-engine 2.62.0 → 2.63.0

package/package.json

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

package/src/core/binary/EncodingBinaryBuffer.js

@@ -1,58 +1,22 @@
+import { BiMap } from "../collection/map/BiMap.js";
 import { BinaryBuffer } from "./BinaryBuffer.js";
 
-class Dictionary {
-    constructor() {
-        this.forward = new Map();
-        this.backward = new Map();
-    }
-
-    /**
-     *
-     * @param {*} value
-     * @param {number} address
-     */
-    add(value, address) {
-        this.forward.set(address, value);
-        this.backward.set(value, address);
-    }
-
-    /**
-     *
-     * @param {*} value
-     * @returns {number|undefined}
-     */
-    getAddress(value) {
-        return this.backward.get(value);
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @returns {*}
-     */
-    getValue(address) {
-        return this.forward.get(address);
-    }
-}
+export class EncodingBinaryBuffer extends BinaryBuffer {
 
+    __dictionary = new BiMap();
 
-export class EncodingBinaryBuffer extends BinaryBuffer {
-    constructor() {
-        super();
-        this.__dictionary = new Dictionary();
-    }
 
     writeUTF8String(value) {
-        const address = this.__dictionary.getAddress(value);
+        const address = this.__dictionary.getKeyByValue(value);
 
         if (address === undefined) {
             this.writeUint8(0); //mark as complete value
 
-            const address1 = this.position;
+            const current_address = this.position;
 
             super.writeUTF8String(value);
 
-            this.__dictionary.add(value, address1);
+            this.__dictionary.add(value, current_address);
         } else {
             //write as reference
             this.writeUint32LE(1 | (address << 1));
@@ -72,7 +36,7 @@ export class EncodingBinaryBuffer extends BinaryBuffer {
 
             const address = header >> 1;
 
-            let value = this.__dictionary.getValue(address);
+            let value = this.__dictionary.getValueByKey(address);
 
             if (value === undefined) {
                 //remember position

package/src/core/binary/EncodingBinaryBuffer.spec.js

@@ -0,0 +1,16 @@
+import { EncodingBinaryBuffer } from "./EncodingBinaryBuffer.js";
+
+test("read/write strings", () => {
+
+    const buffer = new EncodingBinaryBuffer();
+
+    buffer.writeUTF8String("hello world");
+    buffer.writeUTF8String("cat");
+    buffer.writeUTF8String("hello world");
+
+    buffer.position = 0;
+
+    expect(buffer.readUTF8String()).toEqual("hello world");
+    expect(buffer.readUTF8String()).toEqual("cat");
+    expect(buffer.readUTF8String()).toEqual("hello world");
+});

package/src/core/bvh2/bvh3/EBBVHLeafProxy.js

@@ -50,8 +50,10 @@ export class EBBVHLeafProxy {
     unlink() {
         assert.equal(this.is_linked, true, 'not linked');
 
-        this.#tree.remove_leaf(this.#node_id);
-        this.#tree.release_node(this.#node_id);
+        const node_id = this.#node_id;
+
+        this.#tree.remove_leaf(node_id);
+        this.#tree.release_node(node_id);
 
         this.#node_id = -1;
         this.#tree = null;

package/src/core/cache/LoadingCache.js

@@ -1,7 +1,8 @@
 //
 
-import { Cache } from "./Cache.js";
+import { assert } from "../assert.js";
 import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
+import { Cache } from "./Cache.js";
 
 /**
  * @template R
@@ -79,6 +80,8 @@ export class LoadingCache {
                     retryFailed = true
                 }) {
 
+        assert.isFunction(load, 'load');
+
         this.#internal = new Cache({
             maxWeight,
             keyWeigher,

package/src/core/collection/map/BiMap.js

@@ -0,0 +1,49 @@
+/**
+ * Bi-directional map
+ * @template K,V
+ */
+export class BiMap {
+
+    /**
+     *
+     * @type {Map<K, V>}
+     */
+    forward = new Map();
+    /**
+     *
+     * @type {Map<V, K>}
+     */
+    backward = new Map();
+
+
+    /**
+     *
+     * @param {K} key
+     * @param {V} value
+     */
+    add(key, value) {
+        this.forward.set(value, key);
+        this.backward.set(key, value);
+    }
+
+    /**
+     *
+     * @param {V} value
+     * @returns {K|undefined}
+     */
+    getKeyByValue(value) {
+        return this.backward.get(value);
+    }
+
+    /**
+     *
+     * @param {K} address
+     * @returns {V|undefined}
+     */
+    getValueByKey(address) {
+        return this.forward.get(address);
+    }
+}
+
+BiMap.prototype.get = BiMap.prototype.getValueByKey;
+BiMap.prototype.set = BiMap.prototype.add;

package/src/engine/ecs/components/Tag.d.ts

@@ -17,6 +17,8 @@ export class Tag {
 
     containsOneOf(values: string[]): boolean
 
+    hash(): number
+
     equals(other: Tag): boolean
 
     static find(tags: string[], ecd: EntityComponentDataset): number[]

package/src/engine/ecs/components/Tag.js

@@ -3,8 +3,9 @@
  */
 
 
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { assert } from "../../../core/assert.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 
 /**
  * Stores textual tags, useful for marking entities
@@ -12,7 +13,7 @@ import { assert } from "../../../core/assert.js";
 export class Tag {
     /**
      * @private
-     * @type {String[]}
+     * @type {string[]}
      */
     values = [];
 
@@ -194,41 +195,31 @@ export class Tag {
      * @return {boolean}
      */
     equals(other) {
-
-        const s0 = this.values;
-
-        const s1 = other.values;
-
-        const n0 = s0.length;
-        const n1 = s1.length;
-
-        if (n0 !== n1) {
-            //wrong length
-            return false;
-        }
-
-        for (let i = 0; i < n0; i++) {
-            const v0 = s0[i];
-            const v1 = s1[i];
-
-            if (v0 !== v1) {
-                return false;
-            }
-        }
-
-        return true;
+        return isArrayEqualStrict(this.values, other.values);
     }
 
     toJSON() {
         return this.values;
     }
 
+    /**
+     *
+     * @param {string[]|string} json
+     */
     fromJSON(json) {
+
+        this.clear();
+
         if (typeof json === "string") {
-            this.clear();
             this.add(json);
-        } else if (Array.isArray(json)) {
-            this.values = json;
+        } else {
+            assert.isArray(json, 'json');
+
+            const n = json.length;
+
+            for (let i = 0; i < n; i++) {
+                this.add(json[i]);
+            }
         }
     }
 

package/src/engine/ecs/components/Tag.spec.js

@@ -0,0 +1,47 @@
+import Tag from "./Tag.js";
+
+test("constructor", () => {
+    new Tag();
+});
+
+test("containsOneOf", () => {
+
+    const tag = Tag.fromJSON(['a', 'b']);
+
+    expect(tag.containsOneOf([])).toBe(false);
+    expect(tag.containsOneOf(['c'])).toBe(false);
+    expect(tag.containsOneOf(['a'])).toBe(true);
+    expect(tag.containsOneOf(['b'])).toBe(true);
+    expect(tag.containsOneOf(['a', 'b'])).toBe(true);
+
+});
+
+test("hash", () => {
+
+    const tag = Tag.fromJSON(['a', 'b']);
+
+    const hash = tag.hash();
+
+    expect(tag.hash()).toEqual(hash);
+
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("equals", () => {
+
+
+    const a = Tag.fromJSON(['a', 'b']);
+    const b = Tag.fromJSON([]);
+    const c = Tag.fromJSON(['a']);
+    const d = Tag.fromJSON(['b']);
+    const e = Tag.fromJSON(['a', 'b']);
+    const f = Tag.fromJSON(['a', 'c']);
+
+    expect(a.equals(b)).toBe(false);
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+    expect(a.equals(e)).toBe(true);
+    expect(a.equals(f)).toBe(false);
+
+});

package/src/engine/ecs/fow/FogOfWar.js

@@ -208,6 +208,10 @@ export class FogOfWar {
         this.textureNeedsUpdate = true;
     }
 
+    concealAll(){
+        this.clear();
+    }
+
     /**
      *
      * @param {number} x

package/src/engine/ecs/fow/FogOfWarEditor.js

@@ -6,6 +6,9 @@ export class FogOfWarEditor extends ObjectEditor {
             properties: {
                 revealAll: {
                     type: Function
+                },
+                concealAll: {
+                    type: Function
                 }
             }
         };

package/src/engine/ecs/terrain/TerrainPreview.js

@@ -1,66 +1,67 @@
 import Vector2 from "../../../core/geom/Vector2.js";
 
-export function TerrainPreview() {
+export class TerrainPreview {
     /**
      *
      * @type {String}
      */
-    this.url = "";
+    url = "";
 
     /**
      *
      * @type {Vector2}
      */
-    this.offset = new Vector2(0, 0);
+    offset = new Vector2(0, 0);
     /**
      *
      * @type {Vector2}
      */
-    this.scale = new Vector2(1, 1);
-}
+    scale = new Vector2(1, 1);
+
+    /**
+     *
+     * @param {TerrainPreview} other
+     */
+    copy(other) {
+        this.url = other.url;
+        this.scale.copy(other.scale);
+        this.offset.copy(other.offset);
+    }
 
-/**
- *
- * @param {TerrainPreview} other
- */
-TerrainPreview.prototype.copy = function (other) {
-    this.url = other.url;
-    this.scale.copy(other.scale);
-    this.offset.copy(other.offset);
-};
+    toJSON() {
+        return {
+            url: this.url,
+            offset: this.offset.toJSON(),
+            scale: this.scale.toJSON()
+        };
+    }
 
-TerrainPreview.prototype.toJSON = function () {
-    return {
-        url: this.url,
-        offset: this.offset.toJSON(),
-        scale: this.scale.toJSON()
-    };
-};
+    fromJSON(obj) {
+        this.url = obj.url;
+        this.offset.fromJSON(obj.offset);
+        this.scale.fromJSON(obj.scale);
+    }
 
-TerrainPreview.prototype.fromJSON = function (obj) {
-    this.url = obj.url;
-    this.offset.fromJSON(obj.offset);
-    this.scale.fromJSON(obj.scale);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeUTF8String(this.url);
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-TerrainPreview.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeUTF8String(this.url);
+        this.offset.toBinaryBuffer(buffer);
+        this.scale.toBinaryBuffer(buffer);
+    }
 
-    this.offset.toBinaryBuffer(buffer);
-    this.scale.toBinaryBuffer(buffer);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.url = buffer.readUTF8String();
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-TerrainPreview.prototype.fromBinaryBuffer = function (buffer) {
-    this.url = buffer.readUTF8String();
+        this.offset.fromBinaryBuffer(buffer);
+        this.scale.fromBinaryBuffer(buffer);
+    }
+}
 
-    this.offset.fromBinaryBuffer(buffer);
-    this.scale.fromBinaryBuffer(buffer);
-};

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrain.js

@@ -1,8 +1,8 @@
 /**
  * Created by Alex on 13/05/2016.
  */
-import Vector3 from "../../../../../core/geom/Vector3.js";
 import Quaternion from "../../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
 
 class ClingToTerrain {
     /**
@@ -13,12 +13,12 @@ class ClingToTerrain {
      * Used internally for caching updates
      * @type {Vector3}
      */
-    __lastPosition=new Vector3(0, 0, 0);
+    __lastPosition = new Vector3(0, 0, 0);
     /**
      *
      * @type {Quaternion}
      */
-    __lastRotation=new Quaternion(0, 0, 0, 1);
+    __lastRotation = new Quaternion(0, 0, 0, 1);
     /**
      * Speed in Rad/s (Radians/second) by which rotation can change
      * @type {number}
@@ -26,11 +26,29 @@ class ClingToTerrain {
     rotationSpeed = 3;
 
     constructor(opt) {
-        if(opt !== undefined){
+        if (opt !== undefined) {
             throw new Error("constructor options deprecated");
         }
     }
 
+    /**
+     *
+     * @param {ClingToTerrain} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.normalAlign === other.normalAlign
+            && this.rotationSpeed === other.rotationSpeed;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        return this.normalAlign ? 1 : 0;
+    }
+
     toJSON() {
         return {
             normalAlign: this.normalAlign,

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -3,31 +3,36 @@
  */
 
 
+import { mat4 } from "gl-matrix";
 import {
     Box3 as ThreeBox3,
     BufferAttribute as ThreeBufferAttribute,
     BufferGeometry as ThreeBufferGeometry,
+    MeshBasicMaterial,
     Sphere as ThreeSphere,
     Vector3 as ThreeVector3
 } from 'three';
-import Vector2 from '../../../../core/geom/Vector2.js';
-import Vector3 from '../../../../core/geom/Vector3.js';
 
-import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
+import IndexedBinaryBVH from '../../../../core/bvh2/binary/IndexedBinaryBVH.js';
 
 
 import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
-
-import IndexedBinaryBVH from '../../../../core/bvh2/binary/IndexedBinaryBVH.js';
-import { BVHGeometryRaycaster } from "../../../graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js";
-import ObservedInteger from "../../../../core/model/ObservedInteger.js";
-import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import Signal from "../../../../core/events/signal/Signal.js";
-import { mat4 } from "gl-matrix";
+import { passThrough } from "../../../../core/function/Functions.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import Vector2 from '../../../../core/geom/Vector2.js';
+import Vector3 from '../../../../core/geom/Vector3.js';
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
-import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { passThrough } from "../../../../core/function/Functions.js";
+import ObservedInteger from "../../../../core/model/ObservedInteger.js";
+import { BVHGeometryRaycaster } from "../../../graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js";
+
+import ThreeFactory from '../../../graphics/three/ThreeFactory.js';
+
+
+const EMPTY_GEOMETRY = new ThreeBufferGeometry();
+const DEFAULT_MATERIAL = new MeshBasicMaterial();
 
 /**
  * terrain tile is a part of a 2d array
@@ -44,7 +49,7 @@ class TerrainTile {
      * @type {Material}
      */
     material = null;
-    mesh = ThreeFactory.createMesh();
+    mesh = ThreeFactory.createMesh(EMPTY_GEOMETRY, DEFAULT_MATERIAL);
 
 
     /**

package/src/engine/graphics/ecs/mesh/Mesh.d.ts

@@ -5,10 +5,6 @@ import {LeafNode} from "../../../../core/bvh2/LeafNode";
 export default class Mesh {
     url: string
     mesh: Object3D
-    /**
-     * Managed by MeshSystem, do not change
-     */
-    bvh: LeafNode<Object3D>
 
     castShadow: boolean
     receiveShadow: boolean

package/src/engine/graphics/ecs/mesh/Mesh.js

@@ -51,12 +51,6 @@ class Mesh {
          */
         this.mesh = null;
 
-        /**
-         * Override Mesh data, if available. Typically set via plugins
-         * @type {Object3D|null}
-         */
-        this.override_mesh = null;
-
         /**
          * @transient
          * @type {Asset|null}
@@ -129,11 +123,6 @@ class Mesh {
         aabb3_matrix4_project(this.__bvh_leaf.bounds, this.boundingBox, _t.matrix);
 
         this.__bvh_leaf.write_bounds();
-
-        // override
-        if (this.override_mesh !== null) {
-            applyTransformToThreeObject(this.override_mesh, _t);
-        }
     }
 
     /**