@woosh/meep-engine 2.43.42 → 2.43.43

package/core/parser/simple/computeDataTypeFromValue.js

@@ -0,0 +1,25 @@
+import { DataType } from "./DataType.js";
+
+/**
+ * @template T
+ * @param {T} value
+ * @return {DataType}
+ */
+export function computeDataTypeFromValue(value) {
+    const t = typeof value;
+
+    switch (t) {
+        case "number":
+            return DataType.Number;
+        case "string":
+            return DataType.String;
+        case "boolean":
+            return DataType.Boolean;
+        default:
+            if (Array.isArray(value)) {
+                return DataType.Array;
+            }
+
+            throw new Error(`Unsupported value type for value '${value}'`);
+    }
+}

package/engine/graphics/render/gizmo/Gizmo.d.ts

@@ -0,0 +1,3 @@
+import {GizmoShapeRenderingInterface} from "./GizmoShapeRenderingInterface";
+
+export const Gizmo: GizmoShapeRenderingInterface;

package/engine/graphics/render/gizmo/GizmoRenderingPlugin.d.ts

@@ -0,0 +1,5 @@
+import {EnginePlugin} from "../../../plugin/EnginePlugin";
+
+export class GizmoRenderingPlugin extends EnginePlugin{
+    
+}

package/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.d.ts

@@ -0,0 +1,13 @@
+export class GizmoShapeRenderingInterface {
+    color: number[]
+
+    draw_solid_cube(center: number[], size: number[]): void
+
+    draw_wire_cube(center: number[], size: number[]): void
+
+    draw_solid_sphere(center: number[], radius: number): void
+
+    draw_wire_sphere(center: number[], radius: number): void
+
+    static INSTANCE: GizmoShapeRenderingInterface
+}

package/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.js

@@ -37,6 +37,9 @@ function add_instance(group, matrix, color) {
     );
 }
 
+/**
+ * Inspired by IMGUI and Unity's debug renderer
+ */
 export class GizmoShapeRenderingInterface {
     constructor() {
 
@@ -99,6 +102,7 @@ export class GizmoShapeRenderingInterface {
     }
 
     /**
+     * Color used for drawing shapes, draw_x will take on the currently set color when called
      * RGBA
      * @param {number[]} color
      */
@@ -110,6 +114,14 @@ export class GizmoShapeRenderingInterface {
         array_copy(color, 0, this.__color, 0, 4);
     }
 
+    /**
+     * RGBA
+     * @return {number[]}
+     */
+    get color() {
+        return this.__color;
+    }
+
     /**
      *
      * @param {number[]} center

package/engine/intelligence/behavior/Behavior.d.ts

@@ -0,0 +1,11 @@
+import {BehaviorStatus} from "./BehaviorStatus";
+
+export class Behavior<CTX> {
+    context: CTX | null
+
+    tick(timeDeltaSeconds: number): BehaviorStatus
+
+    initialize(context: CTX): void
+
+    finalize(): void
+}

package/engine/intelligence/behavior/Behavior.js

@@ -2,6 +2,7 @@ import { BehaviorStatus } from "./BehaviorStatus.js";
 
 /**
  * Base class of behavior tree implementation
+ * @see "The Behavior Tree Starter Kit" by Alex J. Champandard and Philip Dunstan
  * @template CTX
  */
 export class Behavior {
@@ -14,9 +15,9 @@ export class Behavior {
     }
 
     /**
-     * Main update function
+     * Main update function. Every behavior executes some logic, some behaviors are long-running and some are instantaneous
      * @param {number} timeDelta time step in seconds
-     * @returns {BehaviorStatus}
+     * @returns {BehaviorStatus} signals status of the behavior, "success" or "failure" are used to signal completion of the behavior
      */
     tick(timeDelta) {
         throw new Error('Abstract method, needs to be overridden');
@@ -25,7 +26,7 @@ export class Behavior {
     /**
      * Called before behavior gets executed via {@link #tick} for the first time
      * Used to prepare the behavior for execution
-     * @param {*} [context]
+     * @param {CTX} [context]
      */
     initialize(context) {
         this.context = context;

package/engine/intelligence/behavior/BehaviorStatus.d.ts

@@ -0,0 +1,8 @@
+export enum BehaviorStatus {
+    Initial = 0,
+    Running = 1,
+    Succeeded = 2,
+    Failed = 3,
+    Suspended = 4,
+    Invalid = 5
+}

package/engine/intelligence/behavior/ecs/BehaviorComponent.js

@@ -4,16 +4,11 @@ import { RepeatBehavior } from "../decorator/RepeatBehavior.js";
 import { ActionBehavior } from "../primitive/ActionBehavior.js";
 import { SequenceBehavior } from "../composite/SequenceBehavior.js";
 
-export const BehaviorComponentFlag = {
-    AllowSleep: 1,
-    Resolved: 2
-};
-
 export class BehaviorComponent {
     constructor() {
 
         /**
-         *
+         * What clock should be used for ticking associated behavior
          * @type {ClockChannelType|number}
          */
         this.clock = ClockChannelType.Simulation;
@@ -135,8 +130,8 @@ export class BehaviorComponent {
      * @returns {BehaviorComponent}
      */
     static fromOne(b) {
-        assert.notEqual(b, undefined, 'behavior is undefined');
-        assert.notEqual(b, null, 'behavior is null');
+        assert.defined(b,  'behavior');
+        assert.notNull(b,  'behavior');
         assert.equal(b.isBehavior, true, 'b.isBehavior !== true');
 
         const result = new BehaviorComponent();

package/engine/intelligence/behavior/ecs/BehaviorComponentFlag.js

@@ -0,0 +1,7 @@
+export const BehaviorComponentFlag = {
+    AllowSleep: 1,
+    /**
+     * Behavior has completed
+     */
+    Resolved: 2
+};

package/engine/intelligence/behavior/ecs/BehaviorSystem.js

@@ -1,8 +1,9 @@
 import { System } from "../../../ecs/System.js";
-import { BehaviorComponent, BehaviorComponentFlag } from "./BehaviorComponent.js";
+import { BehaviorComponent } from "./BehaviorComponent.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import Clock from "../../../Clock.js";
 import { ClockChannelType } from "./ClockChannelType.js";
+import { BehaviorComponentFlag } from "./BehaviorComponentFlag.js";
 
 /**
  *

package/engine/intelligence/behavior/ecs/ClockChannelType.js

@@ -3,6 +3,13 @@
  * @enum {number}
  */
 export const ClockChannelType = {
+    /**
+     * Simulation clock is the one that the entire world is running on
+     */
     Simulation: 0,
+    /**
+     * System clock is essentially real-time
+     * Useful for things that need to run even when the world simulation is paused
+     */
     System: 1
 };

package/engine/intelligence/behavior/primitive/SucceedingBehavior.js

@@ -1,6 +1,5 @@
 import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
-import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 
 /**
  * Behavior that always succeeds
@@ -25,7 +24,7 @@ export class SucceedingBehavior extends Behavior {
         return r;
     }
 
-    tick() {
+    tick(timeDelta) {
         if (this.delayTicks === 0) {
             return BehaviorStatus.Succeeded;
         } else {
@@ -37,29 +36,3 @@ export class SucceedingBehavior extends Behavior {
 
 SucceedingBehavior.typeName = "SucceedingBehavior";
 
-export class SucceedingBehaviorSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = SucceedingBehavior;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SucceedingBehavior} value
-     */
-    serialize(buffer, value) {
-        buffer.writeUintVar(value.delayTicks);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SucceedingBehavior} value
-     */
-    deserialize(buffer, value) {
-        value.delayTicks = buffer.readUintVar();
-    }
-}

package/engine/intelligence/behavior/primitive/SucceedingBehaviorSerializationAdapter.js

@@ -0,0 +1,29 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { SucceedingBehavior } from "./SucceedingBehavior.js";
+
+export class SucceedingBehaviorSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = SucceedingBehavior;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {SucceedingBehavior} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUintVar(value.delayTicks);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {SucceedingBehavior} value
+     */
+    deserialize(buffer, value) {
+        value.delayTicks = buffer.readUintVar();
+    }
+}

package/engine/intelligence/blackboard/AbstractBlackboard.js

@@ -13,6 +13,14 @@ export class AbstractBlackboard {
         throw new Error('Not implemented');
     }
 
+    /**
+     * Produces a list of all held keys
+     * @returns {string[]}
+     */
+    getKeys() {
+        throw new Error('Not implemented');
+    }
+
     /**
      * @template T
      * @param {string} name
@@ -30,7 +38,7 @@ export class AbstractBlackboard {
      * @returns {void}
      */
     release(name) {
-
+        throw new Error('Not implemented');
     }
 
     /**

package/engine/intelligence/blackboard/Blackboard.js

@@ -3,6 +3,8 @@ import { assert } from "../../../core/assert.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { BlackboardValue } from "./BlackboardValue.js";
 import { AbstractBlackboard } from "./AbstractBlackboard.js";
+import { make_blackboard_proxy } from "./make_blackboard_proxy.js";
+
 
 export class Blackboard extends AbstractBlackboard {
     constructor() {
@@ -25,47 +27,11 @@ export class Blackboard extends AbstractBlackboard {
         /**
          * @private
          */
-        this.proxy = new Proxy(this, {
-            /**
-             *
-             * @param target
-             * @param {string} p
-             * @param receiver
-             * @returns {*}
-             */
-            get(target, p, receiver) {
-                const data = target.data;
-
-                if (!data.hasOwnProperty(p)) {
-                    // property not found
-                    return undefined;
-                }
-
-                const blackboardValue = data[p];
-
-                const resolved_value = blackboardValue.value.getValue();
-
-                return resolved_value;
-            },
-            set(target, p, value, receiver) {
-
-
-                const blackboardValue = target.data[p];
-
-                if (blackboardValue === undefined) {
-                    // blackboard property not found
-                    return undefined;
-                }
-
-                blackboardValue.value.set(value);
-
-            },
-            ownKeys(target) {
-
-                return Reflect.ownKeys(target.data);
+        this.proxy = make_blackboard_proxy(this);
+    }
 
-            }
-        });
+    getKeys() {
+        return Reflect.ownKeys(this.data);
     }
 
     /**

package/engine/intelligence/blackboard/make_blackboard_proxy.js

@@ -0,0 +1,47 @@
+import DataType from "../../../core/parser/simple/DataType.js";
+import { computeDataTypeFromValue } from "../../../core/parser/simple/computeDataTypeFromValue.js";
+
+/**
+ * Given a blackboard, returns a Proxy instance, exposing blackboard attributes as plain JSON
+ * Useful for connecting blackboard to systems that are not explicitly designed to work with a blackboard
+ * @param {AbstractBlackboard} blackboard
+ * @returns {Proxy}
+ */
+export function make_blackboard_proxy(blackboard) {
+    return new Proxy(blackboard, {
+        /**
+         *
+         * @param target
+         * @param {string} p
+         * @param receiver
+         * @returns {*}
+         */
+        get(target, p, receiver) {
+
+            if (!target.contains(p, DataType.Any)) {
+                // property not found
+                return undefined;
+            }
+
+            const value_container = target.acquire(p, DataType.Any);
+
+            return value_container.getValue();
+        },
+        set(target, p, value, receiver) {
+
+            const dataType = computeDataTypeFromValue(value);
+
+            const value_container = target.acquire(p, dataType, value);
+
+            value_container.set(value);
+
+            // succeeded
+            return true;
+        },
+        ownKeys(target) {
+
+            return target.getKeys();
+
+        }
+    })
+}

package/engine/intelligence/blackboard/make_blackboard_proxy.spec.js

@@ -0,0 +1,23 @@
+import { Blackboard } from "./Blackboard.js";
+import { make_blackboard_proxy } from "./make_blackboard_proxy.js";
+
+test("setters propagate", () => {
+    const bb = new Blackboard();
+
+    const proxy = make_blackboard_proxy(bb);
+
+    proxy.hello = 7;
+
+    expect(bb.acquireNumber('hello').getValue()).toBe(7);
+});
+
+
+test("getters propagate", () => {
+    const bb = new Blackboard();
+
+    bb.acquireNumber('hello').set(7);
+
+    const proxy = make_blackboard_proxy(bb);
+
+    expect(proxy.hello).toBe(7);
+});

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.42",
+  "version": "2.43.43",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",