@woosh/meep-engine 2.46.24 → 2.46.26

package/build/meep.module.js

@@ -99861,25 +99861,34 @@ class RepeatBehavior extends AbstractDecoratorBehavior {
 
 RepeatBehavior.typeName = "RepeatBehavior";
 
+/**
+ * @template CTX
+ * @extends {Behavior<CTX>}
+ */
 class ActionBehavior extends Behavior {
     /**
      *
-     * @param {function(timeDelta:number)} action
-     * @param {*} [context]
+     * @param {function(timeDelta:number, context:CTX)} func
+     * @param {*} [thisArg] defaults to behavior itself if not specified
      */
-    constructor(action, context) {
+    constructor(func, thisArg) {
         super();
 
-        assert.typeOf(action, 'function', "action");
+        assert.typeOf(func, 'function', "action");
 
-        this.__action = action;
-        this.__context = context;
+        this.__action = func;
+
+        if (thisArg === undefined) {
+            this.__context = this;
+        } else {
+            this.__context = thisArg;
+        }
     }
 
     tick(timeDelta) {
 
         try {
-            this.__action.call(this.__context, timeDelta);
+            this.__action.call(this.__context, timeDelta, this.context);
 
             return BehaviorStatus.Succeeded;
 
@@ -120309,7 +120318,7 @@ class LightManager {
          */
         this.__visible_bvh_needs_update = true;
 
-        window.light_manager = this; // DEBUG
+        // window.light_manager = this; // DEBUG
     }
 
     /**

package/package.json

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

package/src/core/model/node-graph/visual/NodeGraphVisualData.js

@@ -112,7 +112,7 @@ export class NodeGraphVisualData {
          *
          * @param {NodeInstancePortReference} ref
          */
-        const getEndpointLayputSpec = (ref) => {
+        const getEndpointLayoutSpec = (ref) => {
             const endpoint = endpoints.get(ref);
 
             if (endpoint !== undefined) {
@@ -141,8 +141,8 @@ export class NodeGraphVisualData {
         }
 
         graph.traverseConnections(connection => {
-            const source = getEndpointLayputSpec(connection.source);
-            const target = getEndpointLayputSpec(connection.target);
+            const source = getEndpointLayoutSpec(connection.source);
+            const target = getEndpointLayoutSpec(connection.target);
 
             const spec = ConnectionLayoutSpec.from(
                 source,

package/src/engine/graphics/ecs/light/shadow/LightShadow.js

@@ -0,0 +1,4 @@
+export class LightShadow {
+    resolution = 32
+
+}

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -326,7 +326,7 @@ export class LightManager {
          */
         this.__visible_bvh_needs_update = true;
 
-        window.light_manager = this; // DEBUG
+        // window.light_manager = this; // DEBUG
     }
 
     /**

package/src/engine/intelligence/behavior/primitive/ActionBehavior.js

@@ -2,25 +2,34 @@ import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * @template CTX
+ * @extends {Behavior<CTX>}
+ */
 export class ActionBehavior extends Behavior {
     /**
      *
-     * @param {function(timeDelta:number)} action
-     * @param {*} [context]
+     * @param {function(timeDelta:number, context:CTX)} func
+     * @param {*} [thisArg] defaults to behavior itself if not specified
      */
-    constructor(action, context) {
+    constructor(func, thisArg) {
         super();
 
-        assert.typeOf(action, 'function', "action");
+        assert.typeOf(func, 'function', "action");
 
-        this.__action = action;
-        this.__context = context;
+        this.__action = func;
+
+        if (thisArg === undefined) {
+            this.__context = this;
+        } else {
+            this.__context = thisArg;
+        }
     }
 
     tick(timeDelta) {
 
         try {
-            this.__action.call(this.__context, timeDelta);
+            this.__action.call(this.__context, timeDelta, this.context);
 
             return BehaviorStatus.Succeeded;
 

package/src/engine/intelligence/behavior/util/BranchBehavior.js

@@ -0,0 +1,97 @@
+import { Behavior } from "../Behavior.js";
+import { SucceedingBehavior } from "../primitive/SucceedingBehavior.js";
+import { assert } from "../../../../core/assert.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+
+const DEFAULT = new SucceedingBehavior();
+
+export class BranchBehavior extends Behavior {
+    #successBranch = DEFAULT
+    #failureBranch = DEFAULT
+    #condition = DEFAULT
+
+    /**
+     *
+     * @type {Behavior|null}
+     */
+    #current = null;
+
+    /**
+     *
+     * @param {Behavior} condition
+     * @param {Behavior} successBranch
+     * @param {Behavior} failureBranch
+     */
+    static from(
+        condition,
+        successBranch = DEFAULT,
+        failureBranch = DEFAULT
+    ) {
+        assert.defined(condition, 'condition');
+        assert.notNull(condition, 'condition');
+        assert.equal(condition.isBehavior, true, 'condition.isBehavior !== true');
+
+        assert.defined(successBranch, 'successBranch');
+        assert.notNull(successBranch, 'successBranch');
+        assert.equal(successBranch.isBehavior, true, 'successBranch.isBehavior !== true');
+
+        assert.defined(failureBranch, 'failureBranch');
+        assert.notNull(failureBranch, 'failureBranch');
+        assert.equal(failureBranch.isBehavior, true, 'failureBranch.isBehavior !== true');
+
+
+        const r = new BranchBehavior();
+
+        r.#condition = condition;
+        r.#successBranch = successBranch;
+        r.#failureBranch = failureBranch;
+
+        return r;
+    }
+
+
+    initialize(context) {
+        super.initialize(context);
+
+        this.#current = this.#condition;
+        this.#current.initialize(context);
+    }
+
+    tick(timeDelta) {
+        const s = this.#current.tick(timeDelta);
+
+        if (s !== BehaviorStatus.Succeeded && s !== BehaviorStatus.Failed) {
+
+            // current behavior was not resolved, continue
+            return s;
+
+        }
+
+        if (this.#current !== this.#condition) {
+            // underlying branch was resolved
+            return s;
+        }
+
+        // condition was resolved, move onto a branch
+        this.#current.finalize();
+
+        if (s === BehaviorStatus.Succeeded) {
+            this.#current = this.#successBranch;
+        } else {
+            this.#current = this.#failureBranch;
+        }
+
+        this.#current.initialize(this.context);
+
+        return this.#current.tick(timeDelta);
+    }
+
+    finalize() {
+        super.finalize();
+
+        if (this.#current !== null) {
+            this.#current.finalize()
+        }
+    }
+
+}