@woosh/meep-engine 2.48.12 → 2.48.14

package/package.json

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

package/src/core/collection/queue/Deque.d.ts

@@ -7,6 +7,8 @@ export class Deque<T> {
 
     size(): number
 
+    isEmpty(): boolean
+
     remove(e: T): boolean
 
     has(e: T): boolean
@@ -17,4 +19,11 @@ export class Deque<T> {
 
     add(e: T): void
 
+    addFirst(e: T): void
+
+    removeFirst(): T
+
+    addLast(e: T): void
+
+    removeLast(): T
 }

package/src/core/collection/queue/Deque.js

@@ -1,6 +1,7 @@
 import { ceilPowerOfTwo } from "../../binary/operations/ceilPowerOfTwo.js";
 import { max2 } from "../../math/max2.js";
 import { array_copy } from "../array/copyArray.js";
+import { assert } from "../../assert.js";
 
 const DEFAULT_SIZE = 16;
 
@@ -18,6 +19,8 @@ export class Deque {
      */
     constructor(minSize = DEFAULT_SIZE) {
 
+        assert.isNonNegativeInteger(minSize, 'minSize');
+
         const size = ceilPowerOfTwo(max2(DEFAULT_SIZE, minSize));
 
         /**

package/src/core/collection/queue/Deque.spec.js

@@ -87,3 +87,54 @@ test('size', () => {
 
     expect(deque.size()).toBe(0);
 });
+
+test("remove the only item", () => {
+    const deque = new Deque();
+
+    deque.add(7);
+
+    expect(deque.remove(7)).toBe(true);
+
+    expect(deque.size()).toBe(0);
+});
+
+test("remove first item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+
+    expect(deque.remove(7)).toBe(true);
+    expect(deque.size()).toBe(1);
+
+    expect(deque.pop()).toBe(13);
+});
+
+test("remove last item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+
+    expect(deque.remove(13)).toBe(true);
+    expect(deque.size()).toBe(1);
+
+    expect(deque.pop()).toBe(7);
+});
+
+test("remove middle item", () => {
+
+    const deque = new Deque();
+
+    deque.add(7);
+    deque.add(13);
+    deque.add(17);
+
+    expect(deque.remove(13)).toBe(true);
+    expect(deque.size()).toBe(2);
+
+    expect(deque.pop()).toBe(7);
+    expect(deque.pop()).toBe(17);
+});

package/src/core/font/FontAssetLoader.js

@@ -4,7 +4,7 @@ import { FontAsset } from "./FontAsset.js";
 
 
 export class FontAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope,path, success, failure, progress) {
         load(path, function (err, font) {
             if (err) {
                 failure(err);
@@ -15,6 +15,6 @@ export class FontAssetLoader extends AssetLoader {
                 success(asset);
 
             }
-        });
+        },{});
     }
 }

package/src/core/math/bessel_3.js

@@ -1,5 +1,6 @@
 /**
  * Kaiser Bessel Function of third kind
+ * NOTE: this is an approximation, if input value is sufficiently large - results will be way off
  * @see https://www.shadertoy.com/view/wlf3RH
  * @returns {number}
  * @param {number} x
@@ -7,5 +8,6 @@
 export function bessel_3(x) {
     const y = 0.5 * x;
     const y2 = (y * y);
-    return (y2 * y * (1.0 / 6.0 + y2 * (1.0 / 24.0 + y2 * (1.0 / 240.0 + y2 * (1.0 / 4320.0 + y2 / 120960.0)))));
+    // return (y2 * y * (1.0 / 6.0 + y2 * (1.0 / 24.0 + y2 * (1.0 / 240.0 + y2 * (1.0 / 4320.0 + y2 / 120960.0)))));
+    return (y2 * y * (0.16666666666666666 + y2 * (0.041666666666666664 + y2 * (0.004166666666666667 + y2 * (2.314814814814815E-4 + y2 * 8.267195767195768E-6)))));
 }

package/src/core/math/noise/create_noise_2d.js

@@ -0,0 +1,193 @@
+/*
+NOTE: this implementation is adapted from https://github.com/jwagner/simplex-noise.js
+ */
+
+// these #__PURE__ comments help uglifyjs with dead code removal
+//
+const F2 = /*#__PURE__*/ 0.5 * (Math.sqrt(3.0) - 1.0);
+const G2 = /*#__PURE__*/ (3.0 - Math.sqrt(3.0)) / 6.0;
+const F3 = 1.0 / 3.0;
+const G3 = 1.0 / 6.0;
+const F4 = /*#__PURE__*/ (Math.sqrt(5.0) - 1.0) / 4.0;
+const G4 = /*#__PURE__*/ (5.0 - Math.sqrt(5.0)) / 20.0;
+const grad2 = /*#__PURE__*/ new Int8Array([1, 1,
+    -1, 1,
+    1, -1,
+
+    -1, -1,
+    1, 0,
+    -1, 0,
+
+    1, 0,
+    -1, 0,
+    0, 1,
+
+    0, -1,
+    0, 1,
+    0, -1]);
+
+// double seems to be faster than single or int's
+// probably because most operations are in double precision
+const grad3 = /*#__PURE__*/ new Float64Array([1, 1, 0,
+    -1, 1, 0,
+    1, -1, 0,
+
+    -1, -1, 0,
+    1, 0, 1,
+    -1, 0, 1,
+
+    1, 0, -1,
+    -1, 0, -1,
+    0, 1, 1,
+
+    0, -1, 1,
+    0, 1, -1,
+    0, -1, -1]);
+
+// double is a bit quicker here as well
+const grad4 = /*#__PURE__*/ new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1,
+    0, -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1,
+    1, 0, 1, 1, 1, 0, 1, -1, 1, 0, -1, 1, 1, 0, -1, -1,
+    -1, 0, 1, 1, -1, 0, 1, -1, -1, 0, -1, 1, -1, 0, -1, -1,
+    1, 1, 0, 1, 1, 1, 0, -1, 1, -1, 0, 1, 1, -1, 0, -1,
+    -1, 1, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, -1,
+    1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1, 0,
+    -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1, 0]);
+
+
+/**
+ * Creates a 2D noise function
+ * @param random the random function that will be used to build the permutation table
+ * @returns {function(x:number, y:number):number}
+ */
+export function createNoise2D(random = Math.random) {
+    // allocate continuous chunk of memory
+    const buffer = new ArrayBuffer(512 * 2);
+
+    const perm = new Uint8Array(buffer, 0, 512);
+    buildPermutationTable(random, perm);
+
+    const permMod12 = new Uint8Array(buffer, 512, 512);
+
+    for (let i = 0; i < 512; i++) {
+        permMod12[i] = (perm[i] % 12) * 2;
+    }
+
+    return function noise2D(x, y) {
+        // if(!isFinite(x) || !isFinite(y)) return 0;
+        let n0 = 0; // Noise contributions from the three corners
+        let n1 = 0;
+        let n2 = 0;
+        // Skew the input space to determine which simplex cell we're in
+        const s = (x + y) * F2; // Hairy factor for 2D
+
+        const i = (x + s) | 0;
+        const j = (y + s) | 0;
+
+        const t = (i + j) * G2;
+        const X0 = i - t; // Unskew the cell origin back to (x,y) space
+        const Y0 = j - t;
+        const x0 = x - X0; // The x,y distances from the cell origin
+        const y0 = y - Y0;
+        // For the 2D case, the simplex shape is an equilateral triangle.
+        // Determine which simplex we are in.
+        let i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+        if (x0 > y0) {
+            i1 = 1;
+            j1 = 0;
+        } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+        else {
+            i1 = 0;
+            j1 = 1;
+        } // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+        // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+        // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+        // c = (3-sqrt(3))/6
+        const x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+        const y1 = y0 - j1 + G2;
+        const x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+        const y2 = y0 - 1.0 + 2.0 * G2;
+        // Work out the hashed gradient indices of the three simplex corners
+        const ii = i & 255;
+        const jj = j & 255;
+        // Calculate the contribution from the three corners
+        let t0 = 0.5 - x0 * x0 - y0 * y0;
+
+        if (t0 >= 0) {
+            const gi0 = ii + perm[jj];
+            const gi01 = permMod12[gi0];
+
+            const g0x = grad2[gi01];
+            const g0y = grad2[gi01 + 1];
+
+            t0 *= t0;
+            // n0 = t0 * t0 * (grad2[gi0] * x0 + grad2[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
+            n0 = t0 * t0 * (g0x * x0 + g0y * y0);
+        }
+
+        let t1 = 0.5 - x1 * x1 - y1 * y1;
+
+        if (t1 >= 0) {
+            const gi1 = ii + i1 + perm[jj + j1];
+            const gi11 = permMod12[gi1];
+
+            const g1x = grad2[gi11];
+            const g1y = grad2[gi11 + 1];
+
+            t1 *= t1;
+            // n1 = t1 * t1 * (grad2[gi1] * x1 + grad2[gi1 + 1] * y1);
+            n1 = t1 * t1 * (g1x * x1 + g1y * y1);
+        }
+
+        let t2 = 0.5 - x2 * x2 - y2 * y2;
+
+        if (t2 >= 0) {
+            const gi2 = ii + 1 + perm[jj + 1];
+
+            const gi21 = permMod12[gi2];
+
+            const g2x = grad2[gi21];
+            const g2y = grad2[gi21 + 1];
+
+            t2 *= t2;
+            // n2 = t2 * t2 * (grad2[gi2] * x2 + grad2[gi2 + 1] * y2);
+            n2 = t2 * t2 * (g2x * x2 + g2y * y2);
+        }
+
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to return values in the interval [-1,1].
+        return 70.0 * (n0 + n1 + n2);
+    };
+}
+
+/**
+ * Builds a random permutation table.
+ * This is exported only for (internal) testing purposes.
+ * Do not rely on this export.
+ * @param {function} random
+ * @param {Uint8Array} p
+ * @private
+ */
+export function buildPermutationTable(random, p) {
+    const table_size = 512;
+
+    const half_table_size = table_size >>> 1;
+
+    for (let i = 0; i < half_table_size; i++) {
+        p[i] = i;
+    }
+
+    for (let i = 0; i < half_table_size - 1; i++) {
+        const r = i + ~~(random() * (256 - i));
+        const aux = p[i];
+
+        p[i] = p[r];
+        p[r] = aux;
+    }
+
+    for (let i = 256; i < table_size; i++) {
+        p[i] = p[i - 256];
+    }
+
+    return p;
+}

package/src/core/path/computeFileExtension.js

@@ -6,8 +6,9 @@ import { computePathBase } from "./computePathBase.js";
  * @returns {String|null}
  */
 export function computeFileExtension(path) {
-    if (typeof path !== "string") {
-        throw new Error('path is not a string');
+    const type_of_path = typeof path;
+    if (type_of_path !== "string") {
+        throw new Error(`path must be a string, instead was '${type_of_path}'`);
     }
 
     //get base

package/src/engine/Engine.js

@@ -100,6 +100,15 @@ class Engine {
          */
         this.ticker = new Ticker();
 
+        /**
+         *
+         * @type {AssetManager<Engine>}
+         */
+        this.assetManager = new AssetManager({
+            context:this,
+            executor: this.executor
+        });
+
         this.__performacne_monitor = new PeriodicConsolePrinter(15, () => {
             const metrics = this.performance;
             const stats = new MetricStatistics();
@@ -198,11 +207,6 @@ class Engine {
          */
         this.storage = this.platform.getStorage();
 
-        /**
-         *
-         * @type {AssetManager}
-         */
-        this.assetManager = new AssetManager(this);
 
         this.localization = new Localization();
         this.localization.setAssetManager(this.assetManager);
@@ -374,9 +378,11 @@ class Engine {
     loadAssetList(listURL) {
         const preloader = new Preloader();
         const assetManager = this.assetManager;
-        assetManager.get(listURL, "json", function (asset) {
-            preloader.addAll(asset.create());
-            preloader.load(assetManager);
+        assetManager.get({
+            path: listURL, type: "json", callback: function (asset) {
+                preloader.addAll(asset.create());
+                preloader.load(assetManager);
+            }
         });
         return preloader;
     }

package/src/engine/achievements/AchievementManager.js

@@ -244,31 +244,31 @@ export class AchievementManager extends EnginePlugin {
     loadDefinitions(assetManager) {
         return new Promise((resolve, reject) => {
             assetManager.get(
-                "data/database/achievements/data.json",
-                GameAssetType.JSON,
-                (asset) => {
-                    try {
+                {
+                    path: "data/database/achievements/data.json", type: GameAssetType.JSON, callback: (asset) => {
+                        try {
 
-                        const json = asset.create();
+                            const json = asset.create();
 
-                        json.forEach(def => {
-                            const achievement = new Achievement();
+                            json.forEach(def => {
+                                const achievement = new Achievement();
 
-                            achievement.fromJSON(def);
+                                achievement.fromJSON(def);
 
-                            this.entries.push(achievement);
-                        });
+                                this.entries.push(achievement);
+                            });
 
-                    } catch (e) {
+                        } catch (e) {
 
-                        reject(e);
+                            reject(e);
 
-                        return;
-                    }
+                            return;
+                        }
 
-                    resolve();
+                        resolve();
 
-                }, reject);
+                    }, failure: reject
+                });
         });
     }
 

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

@@ -2,14 +2,19 @@ import {AssetLoader} from "./loaders/AssetLoader";
 import {Asset} from "./Asset";
 import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
 import {AssetTransformer} from "./AssetTransformer";
-import Engine from "../Engine";
+import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor";
 
 interface PromiseOptions {
     skip_queue: boolean
 }
 
-export class AssetManager {
-    constructor(engine: Engine)
+interface AssetManagerOptions<CTX> {
+    context: CTX,
+    executor?: ConcurrentExecutor
+}
+
+export declare class AssetManager<CTX> {
+    constructor(options?: AssetManagerOptions<CTX>)
 
     public readonly crossOriginConfig: CrossOriginConfig
 
@@ -25,11 +30,11 @@ export class AssetManager {
 
     clear(): void
 
-    registerLoader<T>(type: string, loader: AssetLoader<T>): Promise<AssetLoader<T>>
+    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T,CTX>>
 
     unregisterLoader(type: string): Promise<void>
 
-    getLoaderByType<T>(type: string): AssetLoader<T> | undefined
+    getLoaderByType<T>(type: string): AssetLoader<T, CTX> | undefined
 
     registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
 

package/src/engine/asset/AssetManager.js

@@ -19,6 +19,10 @@ import { AssetRequest, AssetRequestFlags } from "./AssetRequest.js";
 import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
 import { AssetLoadState } from "./AssetLoadState.js";
 import { PendingAsset } from "./PendingAsset.js";
+import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor.js";
+import { AssetLoader } from "./loaders/AssetLoader.js";
+import { array_push_if_unique } from "../../core/collection/array/array_push_if_unique.js";
+import { AssetRequestScope } from "./AssetRequestScope.js";
 
 
 class Response {
@@ -45,6 +49,7 @@ function get_pending_asset_priority_score(pending_asset) {
 
 /**
  * Handles loading/generating assets
+ * @template CTX
  * @class
  */
 export class AssetManager {
@@ -164,19 +169,30 @@ export class AssetManager {
 
     /**
      *
-     * @type {Engine|null}
+     * @type {CTX|null}
      * @private
      */
-    #engine = null;
+    #context = null;
 
     /**
      *
-     * @param {Engine} engine
+     * @type {ConcurrentExecutor|null}
+     */
+    #executor = null;
+
+    /**
+     *
+     * @param {CTX} context
+     * @param {ConcurrentExecutor} executor
      * @constructor
      */
-    constructor(engine) {
+    constructor({
+                    context,
+                    executor = new ConcurrentExecutor()
+                } = {}) {
 
-        this.#engine = engine;
+        this.#context = context;
+        this.#executor = executor;
 
     }
 
@@ -185,7 +201,7 @@ export class AssetManager {
             return;
         }
 
-        this.#engine.executor.run(this.#response_processor);
+        this.#executor.run(this.#response_processor);
 
         this.#is_running = true;
     }
@@ -205,7 +221,7 @@ export class AssetManager {
             await Promise.allSettled([Task.promise(this.#response_processor)]);
         }
 
-        this.#engine.executor.removeTask(this.#response_processor);
+        this.#executor.removeTask(this.#response_processor);
 
         this.#is_running = false;
     }
@@ -237,12 +253,19 @@ export class AssetManager {
     /**
      * @param {String} path
      * @param {String} type
+     * @param {AssetRequestScope} [scope]
      * @param {boolean} [skip_queue] if true will skip the queue and dispatch request immediately
      * @returns {Promise<Asset>}
      */
-    promise(path, type, { skip_queue = false } = {}) {
+    promise(path, type, { scope, skip_queue = false } = {}) {
         return new Promise((resolve, reject) => {
-            this.get(path, type, resolve, reject);
+            this.get({
+                path,
+                type,
+                callback: resolve,
+                failure: reject,
+                scope
+            });
         });
     }
 
@@ -254,13 +277,23 @@ export class AssetManager {
      * @param {function(*)} [failure]
      * @param {function(loaded:number, total:number)} [progress]
      * @param {boolean} [skip_queue]
-     */
-    get(path, type, callback, failure = console.error, progress = noop, skip_queue = false) {
+     * @param {AssetRequestScope} [scope]
+     */
+    get({
+            path,
+            type,
+            callback,
+            failure = console.error,
+            progress = noop,
+            skip_queue = false,
+            scope = null
+        }) {
+
         if (typeof path !== "string") {
-            throw new Error("Path must be string. Path = " + JSON.stringify(path));
+            throw new TypeError(`Path must be string. instead was '${typeof path}'`);
         }
 
-        if(typeof type !== "string"){
+        if (typeof type !== "string") {
             throw new TypeError(`type must be a string, instead was '${typeof type}'`);
         }
 
@@ -274,6 +307,7 @@ export class AssetManager {
             //create request object
             const assetRequest = new AssetRequest(callback, failure, progress);
 
+            assetRequest.scope = scope;
             assetRequest.writeFlag(AssetRequestFlags.SkipQueue, skip_queue);
 
             //submit request
@@ -526,18 +560,34 @@ export class AssetManager {
             pendingAsset.progress.setUpperLimit(total);
         }
 
-        try {
-            const fullPath = this.rootPath + path;
+        // collect scopes
+        const scopes = [];
 
-            if (typeof loader === "function") {
+        for (let i = 0; i < requests.length; i++) {
+            const request = requests[i];
+            const request_scope = request.scope;
 
-                loader(fullPath, success, failure, progress);
+            if (request_scope !== null) {
+                array_push_if_unique(scopes, request_scope)
+            }
+        }
 
-            } else {
+        let scope;
+        if (scopes.length > 0) {
+            scope = AssetRequestScope.from(scopes);
+        } else {
+            scope = AssetRequestScope.GLOBAL;
+        }
 
-                loader.load(fullPath, success, failure, progress);
 
-            }
+        const full_path = this.rootPath + path;
+
+        // console.log(`Request type: ${type}, path: ${path}, scope: ${scope}`);
+
+        try {
+
+
+            loader.load(scope, full_path, success, failure, progress);
 
         } catch (e) {
             console.error(`Loader failed on invocation. path=${path}, type=${type}`, 'Loader exception: ', e);
@@ -689,20 +739,25 @@ export class AssetManager {
             }
         }
 
-        if (typeof loader === "function") {
 
+        let _loader = loader;
+
+        if (typeof _loader === "function") {
+
+            _loader = new AssetLoader();
+            _loader.load = loader;
 
             console.warn(`function-based loaders are deprecated (${type})`);
 
         } else {
 
-            await loader.link(this, this.#engine);
+            await _loader.link(this, this.#context);
 
         }
 
-        this.#loaders[type] = loader;
+        this.#loaders[type] = _loader;
 
-        return loader;
+        return _loader;
     }
 
     /**

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

@@ -16,7 +16,7 @@ function dummyEngine() {
 }
 
 class DummyLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope,path, success, failure, progress) {
         success(new Asset(() => 1));
     }
 }