@woosh/meep-engine 2.49.6 → 2.49.8

package/src/core/parser/simple/readUnsignedIntegerToken.spec.js

@@ -0,0 +1,6 @@
+import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.js";
+
+test("sequence with all digits", () => {
+    const token = readUnsignedIntegerToken("1234567890", 0, 10);
+    expect(token.value).toEqual(1234567890);
+});

package/src/core/process/executor/ConcurrentExecutor.js

@@ -7,7 +7,6 @@ import { IllegalStateException } from "../../fsm/exceptions/IllegalStateExceptio
 import { objectKeyByValue } from "../../model/object/objectKeyByValue.js";
 import { TaskSignal } from "../task/TaskSignal.js";
 import TaskState from "../task/TaskState.js";
-import { clamp } from "../../math/clamp.js";
 
 /**
  *
@@ -22,13 +21,20 @@ function isGroup(t) {
  * @class
  */
 class ConcurrentExecutor {
+    #cycle_count = 0;
+    /**
+     * Handle of the last scheduled `setTimeout`
+     * @type {number}
+     */
+    #timeout_handle = -1;
+
     /**
      *
      * @param {number} [quietTime] in milliseconds
      * @param {number} [workTime] in milliseconds
      * @constructor
      */
-    constructor(quietTime=1, workTime=15) {
+    constructor(quietTime = 1, workTime = 15) {
         /**
          *
          * @type {number}
@@ -58,6 +64,8 @@ class ConcurrentExecutor {
             completed: new Signal()
         };
 
+        this.busy = false;
+
         /**
          *
          * @type {number|SchedulingPolicy}
@@ -298,142 +306,188 @@ class ConcurrentExecutor {
     }
 
     /**
-     * kicks the scheduler into action, this is an internal method and should not be called from outside
-     * @private
+     *
+     * @return {Task|undefined}
      */
-    prod() {
-        const self = this;
+    #pick_next_task() {
+        const ready = this.queueReady;
+
+        switch (this.policy) {
+            case ConcurrentExecutor.POLICY.ROUND_ROBIN:
+                return ready[this.#cycle_count % ready.length];
+            default:
+                console.warn('Unknown scheduling policy: ', this.policy, 'Defaulting to sequential');
+            // fallthrough
+            case ConcurrentExecutor.POLICY.SEQUENTIAL:
+                return ready[0];
+        }
+    }
+
+    /**
+     *
+     * @param {Task} task
+     */
+    #complete_task(task) {
+        const readyTasks = this.queueReady;
+
+        const taskIndex = readyTasks.indexOf(task);
+
+        if (taskIndex !== -1) {
+            readyTasks.splice(taskIndex, 1);
+        } else {
+            console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
+        }
+
 
-        let i = 0;
+        task.state.set(TaskState.SUCCEEDED);
+        task.on.completed.send1(this);
 
         this.resolveTasks();
 
+        this.on.task_completed.send1(task);
+        // console.warn(`Task complete '${task.name}', cycles=${task.__executedCycleCount}, time=${task.__executedCpuTime}`);
+
+    }
+
+    /**
+     *
+     * @param {Task} task
+     * @param {*} [reason]
+     */
+    #fail_task(task, reason) {
         const readyTasks = this.queueReady;
-        let readyTaskCount;
+        const taskIndex = readyTasks.indexOf(task);
 
-        function updateTaskCount() {
-            readyTaskCount = readyTasks.length;
+        if (taskIndex !== -1) {
+            readyTasks.splice(taskIndex, 1);
+        } else {
+            console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
         }
 
-        function pickNextTaskRoundRobin() {
-            return readyTasks[i++ % readyTaskCount];
-        }
+        task.state.set(TaskState.FAILED);
+        task.on.failed.send1(reason);
 
-        function pickNextTaskSequential() {
-            return readyTasks[0];
-        }
+        this.resolveTasks();
 
-        /**
-         * @type {function():Task}
-         */
-        let pickNextTask;
+        this.on.task_completed.send1(task);
+    }
 
-        switch (this.policy) {
-            case ConcurrentExecutor.POLICY.ROUND_ROBIN:
-                pickNextTask = pickNextTaskRoundRobin;
-                break;
-            case ConcurrentExecutor.POLICY.SEQUENTIAL:
-                pickNextTask = pickNextTaskSequential;
-                break;
-            default:
-                console.warn('Unknown scheduling policy: ', this.policy, 'Defaulting to sequential');
-                pickNextTask = pickNextTaskSequential;
-                break;
-        }
+    /**
+     *
+     * @param {Task} task
+     * @param {number} time in milliseconds
+     * @param {function} completionCallback
+     * @param {function} failureCallback
+     */
+    #runTaskForTimeMonitored(task, time) {
+        let cycle_count = 0;
 
         /**
          *
-         * @param {Task} task
+         * @type {function(): TaskSignal}
          */
-        function completeTask(task) {
+        const cycle = task.cycle;
 
-            const taskIndex = readyTasks.indexOf(task);
+        const startTime = performance.now();
 
-            if (taskIndex !== -1) {
-                readyTasks.splice(taskIndex, 1);
-            } else {
-                console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
-            }
+        const endTime = startTime + time;
 
+        //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
+        let t = startTime + 0.000001;
 
-            task.state.set(TaskState.SUCCEEDED);
-            task.on.completed.send1(self);
+        let signal;
 
-            self.resolveTasks();
-            updateTaskCount();
+        while (t < endTime) {
+            cycle_count++;
 
-            self.on.task_completed.send1(task);
-            // console.warn(`Task complete '${task.name}', cycles=${task.__executedCycleCount}, time=${task.__executedCpuTime}`);
-        }
+            signal = cycle();
+            t = performance.now();
 
-        /**
-         *
-         * @param {Task} task
-         * @param {*} reason
-         */
-        function failTask(task, reason) {
-            const taskIndex = readyTasks.indexOf(task);
+            if (signal === TaskSignal.Continue) {
+                continue;
+            }
+
+            if (signal === TaskSignal.Yield) {
+                //give up current quanta
+                break;
+            }
 
-            if (taskIndex !== -1) {
-                readyTasks.splice(taskIndex, 1);
+            if (signal === TaskSignal.EndSuccess) {
+                break;
+            } else if (signal === TaskSignal.EndFailure) {
+                break;
             } else {
-                console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
+                throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
             }
+        }
 
-            task.state.set(TaskState.FAILED);
-            task.on.failed.dispatch(reason);
+        const executionDuration = t - startTime;
 
-            self.resolveTasks();
-            updateTaskCount();
+        task.__executedCpuTime += executionDuration;
+        task.__executedCycleCount += cycle_count;
 
-            self.on.task_completed.send1(task);
+        if (signal === TaskSignal.EndSuccess) {
+            this.#complete_task(task);
+        } else if (signal === TaskSignal.EndFailure) {
+            this.#fail_task(task, "Task signalled failure");
         }
 
-        function executeTimeSlice() {
-            let sliceTimeLeft = self.workTime;
+        return executionDuration;
+    }
 
-            let executionTime = 0;
+    #bound_executeTimeSlice = this.#executeTimeSlice.bind(this);
 
-            while (readyTaskCount > 0) {
-                const task = pickNextTask();
+    #executeTimeSlice() {
+        let sliceTimeLeft = this.workTime;
 
-                if (task === undefined) {
-                    console.warn('Next task not found, likely result of removing task mid-execution');
-                    break;
-                }
+        let executionTime = 0;
 
-                try {
-                    executionTime = runTaskForTimeMonitored(task, sliceTimeLeft, completeTask, failTask);
-                } catch (e) {
-                    console.error(`Task threw an exception`, task, e);
-                    failTask(task, e);
-                }
+        const queueReady = this.queueReady;
 
-                //make sure that execution time that we subtract from current CPU slice is always reducing the slice
-                sliceTimeLeft -= Math.max(executionTime, 1);
+        while (queueReady.length > 0) {
+            const task = this.#pick_next_task();
 
-                if (sliceTimeLeft <= 0) {
-                    break;
-                }
+            if (task === undefined) {
+                console.warn('Next task not found, likely result of removing task mid-execution');
+                break;
             }
 
-            //update task count
-            updateTaskCount();
+            try {
+                executionTime = this.#runTaskForTimeMonitored(task, sliceTimeLeft);
+            } catch (e) {
+                console.error(`Task threw an exception`, task, e);
+                this.#fail_task(task, e);
+            }
 
-            if (readyTaskCount > 0) {
-                //schedule next time slice
-                setTimeout(executeTimeSlice, self.quietTime);
-            } else {
-                self.busy = false;
-                self.on.completed.send0();
+            this.#cycle_count++;
+
+            //make sure that execution time that we subtract from current CPU slice is always reducing the slice
+            sliceTimeLeft -= Math.max(executionTime, 1);
+
+            if (sliceTimeLeft <= 0) {
+                break;
             }
         }
 
-        updateTaskCount();
+        if (this.queueReady.length === 0) {
+            this.busy = false;
+            this.on.completed.send0();
+        } else {
+            //schedule next time slice
+            this.#timeout_handle = setTimeout(this.#bound_executeTimeSlice, this.quietTime);
+        }
+    }
+
+    /**
+     * kicks the scheduler into action, this is an internal method and should not be called from outside
+     * @private
+     */
+    prod() {
+        this.resolveTasks();
 
-        if (!this.busy && readyTaskCount > 0) {
+        if (!this.busy && this.queueReady.length > 0) {
             this.busy = true;
-            executeTimeSlice();
+            this.#executeTimeSlice();
         }
 
     }
@@ -459,147 +513,6 @@ const SchedulingPolicy = {
 
 ConcurrentExecutor.POLICY = SchedulingPolicy;
 
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTimeEstimated(task, time, completionCallback, failureCallback) {
-    let cycle_count = 0;
-
-    /**
-     *
-     * @type {function(): TaskSignal}
-     */
-    const cycle = task.cycle;
-
-    const startTime = performance.now();
-
-    let signal;
-
-    const cycle_time = task.__executedCpuTime / task.__executedCycleCount;
-
-    const estimated_cycles = clamp(Math.ceil(time / cycle_time), 1, 10000);
-
-    while (cycle_count < estimated_cycles) {
-        cycle_count++
-
-        signal = cycle();
-
-        if (signal === TaskSignal.Continue) {
-            continue;
-        }
-
-        if (signal === TaskSignal.Yield) {
-            //give up current quanta
-            break;
-        }
-
-        if (signal === TaskSignal.EndSuccess) {
-            break;
-        } else if (signal === TaskSignal.EndFailure) {
-            break;
-        } else {
-            throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
-        }
-    }
-
-    //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
-    const endTime = performance.now() + 0.000001;
-
-    const executionDuration = endTime - startTime;
-
-    task.__executedCpuTime += executionDuration;
-    task.__executedCycleCount += cycle_count;
-
-    if (signal === TaskSignal.EndSuccess) {
-        completionCallback(task);
-    } else if (signal === TaskSignal.EndFailure) {
-        failureCallback(task, "Task signalled failure");
-    }
-
-    return executionDuration;
-}
-
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTime2(task, time, completionCallback, failureCallback) {
-    if (task.__executedCycleCount > 1000) {
-        return runTaskForTimeEstimated(task, time, completionCallback, failureCallback);
-    } else {
-        return runTaskForTimeMonitored(task, time, completionCallback, failureCallback);
-    }
-}
-
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTimeMonitored(task, time, completionCallback, failureCallback) {
-    let cycle_count = 0;
-
-    /**
-     *
-     * @type {function(): TaskSignal}
-     */
-    const cycle = task.cycle;
-
-    const startTime = performance.now();
-
-    const endTime = startTime + time;
-
-    //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
-    let t = startTime + 0.000001;
-
-    let signal;
-
-    while (t < endTime) {
-        cycle_count++;
-
-        signal = cycle();
-        t = performance.now();
-
-        if (signal === TaskSignal.Continue) {
-            continue;
-        }
-
-        if (signal === TaskSignal.Yield) {
-            //give up current quanta
-            break;
-        }
-
-        if (signal === TaskSignal.EndSuccess) {
-            break;
-        } else if (signal === TaskSignal.EndFailure) {
-            break;
-        } else {
-            throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
-        }
-    }
-
-    const executionDuration = t - startTime;
-
-    task.__executedCpuTime += executionDuration;
-    task.__executedCycleCount += cycle_count;
-
-    if (signal === TaskSignal.EndSuccess) {
-        completionCallback(task);
-    } else if (signal === TaskSignal.EndFailure) {
-        failureCallback(task, "Task signalled failure");
-    }
-
-    return executionDuration;
-}
 
 const ResolutionType = {
     READY: 0,

package/src/engine/Engine.d.ts

@@ -12,7 +12,9 @@ import {EnginePluginManager} from "./plugin/EnginePluginManager";
 import ConcurrentExecutor from "../core/process/executor/ConcurrentExecutor";
 
 export interface IEngineInitializationOptions {
-    entityManager?: EntityManager
+    entityManager?: EntityManager,
+    enableAudio?: boolean
+    enableGraphics?: boolean
 }
 
 export default class Engine {
@@ -25,7 +27,7 @@ export default class Engine {
     public readonly sound: SoundEngine
     public readonly graphics: GraphicsEngine
     public readonly devices: { keyboard: KeyboardDevice, pointer: PointerDevice }
-    public readonly assetManager: AssetManager
+    public readonly assetManager: AssetManager<Engine>
     public readonly ticker: Ticker
     public readonly plugins: EnginePluginManager
     public readonly executor: ConcurrentExecutor

package/src/engine/Engine.js

@@ -5,7 +5,6 @@
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
 
 import { AssetManager } from './asset/AssetManager.js';
-import InputEngine from './InputEngine.js';
 import { GraphicsEngine } from './graphics/GraphicsEngine.js';
 import SoundEngine from './sound/SoundEngine.js';
 import { PerspectiveCamera as ThreePerspectiveCamera } from 'three';
@@ -49,9 +48,15 @@ class Engine {
      *
      * @param {EnginePlatform} platform
      * @param {EntityManager} [entityManager]
+     * @param enableGraphics
+     * @param enableAudio
      * @constructor
      */
-    constructor(platform, { entityManager } = {}) {
+    constructor(platform, {
+        entityManager,
+        enableGraphics = true,
+        enableAudio = true
+    } = {}) {
         assert.defined(platform, 'platform');
 
         /**
@@ -105,7 +110,7 @@ class Engine {
          * @type {AssetManager<Engine>}
          */
         this.assetManager = new AssetManager({
-            context:this,
+            context: this,
             executor: this.executor
         });
 
@@ -159,11 +164,6 @@ class Engine {
             });
         }
 
-
-        this.initialize();
-    }
-
-    initialize() {
         // initialize performance metrics
         this.performance.create({
             name: METRIC_ID_RENDER
@@ -218,29 +218,39 @@ class Engine {
         this.camera = new ThreePerspectiveCamera(45, innerWidth / innerHeight, 1, 50);
 
 
-        /**
-         *
-         * @type {GraphicsEngine}
-         */
-        const ge = this.graphics = new GraphicsEngine(this.camera, this.entityManager);
+        if (enableGraphics !== false) {
 
-        try {
-            ge.start();
-        } catch (e) {
-            logger.info("Failed to start GraphicEngine: ", e);
-        }
+            const graphicsEngine = new GraphicsEngine(this.camera, this.entityManager);
 
-        this.inputEngine = new InputEngine(ge.domElement, window);
+            /**
+             *
+             * @type {GraphicsEngine}
+             */
+            this.graphics = graphicsEngine;
 
-        //sound engine
-        const soundEngine = new SoundEngine();
-        soundEngine.volume = 1;
+            try {
+                graphicsEngine.start();
+            } catch (e) {
+                logger.info("Failed to start GraphicEngine: ", e);
+            }
 
-        /**
-         *
-         * @type {SoundEngine}
-         */
-        this.sound = soundEngine;
+        } else {
+            logger.info('enableGraphics option is not set, no graphics engine will be created');
+        }
+
+        if (enableAudio !== false) {
+            //sound engine
+            const soundEngine = new SoundEngine();
+            soundEngine.volume = 1;
+
+            /**
+             *
+             * @type {SoundEngine}
+             */
+            this.sound = soundEngine;
+        } else {
+            logger.info('enableAudio option is not set, no audio engine will be created');
+        }
 
         /**
          * Graphical User Interface engine
@@ -281,14 +291,20 @@ class Engine {
         this.plugins.initialize(this);
     }
 
+
+    get inputEngine() {
+        throw new Error('Deprecated, use .devices instead');
+    }
+
+    /**
+     * @deprecated
+     */
     get grid() {
         throw new Error('Deprecated, use systems/components to achieve the same functionality as before');
     }
 
     initializeViews() {
 
-        const viewport = this.graphics.viewport;
-
         const gameView = new EmptyView();
 
         gameView.addClass('game-view');
@@ -299,23 +315,28 @@ class Engine {
             position: "absolute",
             pointerEvents: "none"
         });
-
-        viewport.css({
-            pointerEvents: "auto"
-        });
-
         this.gameView = gameView;
 
-        gameView.addChild(viewport);
 
         this.viewStack = new ViewStack();
-        this.viewStack.push(gameView,'game-view');
+        this.viewStack.push(gameView, 'game-view');
 
-        //bind size of renderer viewport to game view
-        viewport.bindSignal(gameView.size.onChanged, viewport.size.set.bind(viewport.size));
-        gameView.on.linked.add(function () {
-            viewport.size.copy(gameView.size);
-        });
+        if (this.graphics !== undefined) {
+
+            const viewport = this.graphics.viewport;
+
+            viewport.css({
+                pointerEvents: "auto"
+            });
+
+            gameView.addChild(viewport);
+            //bind size of renderer viewport to game view
+            viewport.bindSignal(gameView.size.onChanged, viewport.size.set.bind(viewport.size));
+            gameView.on.linked.add(function () {
+                viewport.size.copy(gameView.size);
+            });
+
+        }
     }
 
     initializeSettings() {

package/src/engine/Engine.spec.js

@@ -0,0 +1,11 @@
+import Engine from "./Engine.js";
+import { InMemoryEnginePlatform } from "./platform/InMemoryEnginePlatform.js";
+
+test("constructor does not throw", () => {
+    const platform = new InMemoryEnginePlatform();
+
+    expect(() => new Engine(platform, {
+        enableAudio: false,
+        enableGraphics: false
+    })).not.toThrow();
+});

package/src/engine/InputEngine.js

@@ -4,8 +4,20 @@
  * Time: 20:15
  */
 import { KeyCodes } from './input/devices/KeyCodes.js';
+import { assert } from "../core/assert.js";
 
+/**
+ * @deprecated use PointerDevice and KeyboardDevice respectively
+ * @param pointerContext
+ * @param keyContext
+ * @constructor
+ */
 const InputEngine = function (pointerContext, keyContext) {
+    assert.defined(pointerContext, 'pointerContext');
+    assert.defined(keyContext, 'keyContext');
+
+    console.warn('deprecated, use PointerDevice and KeyboardDevice instead');
+
     const keyMap = [];
     const mouseMap = {};