@woosh/meep-engine 2.46.25 → 2.46.27

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

@@ -0,0 +1,102 @@
+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();
+
+/**
+ * Utility behavior that works just like an IF/ELSE statement
+ * If you are not sure if this is the right behavior for your use-case, consider using a selector behavior instead,
+ * as selector is a more commonly applicable behavior type
+ */
+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()
+        }
+    }
+
+}

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

@@ -1,83 +0,0 @@
-import { CompositeBehavior } from "../composite/CompositeBehavior.js";
-import { BehaviorStatus } from "../BehaviorStatus.js";
-
-export class SelectorBehavior extends CompositeBehavior {
-    constructor() {
-        super();
-
-        this.__index = 0;
-    }
-
-    /**
-     *
-     * @param {Behavior[]} children
-     * @return {SelectorBehavior}
-     */
-    static from(children) {
-        const r = new SelectorBehavior();
-
-        r.__children = children.slice();
-
-        return r;
-    }
-
-    tick(timeDelta) {
-        const children = this.__children;
-        const child_count = children.length;
-
-        if (child_count === 0) {
-            // arbitrarily decide success
-            return BehaviorStatus.Succeeded;
-        }
-
-        for (; ;) {
-            const child = children[this.__index];
-
-            const s = child.tick(timeDelta);
-
-            //if child succeeds or keeps running, do the same
-            if (s !== BehaviorStatus.Failed) {
-                return s;
-            }
-
-
-            //continue search for fallback behavior until the last child
-            this.__index++;
-
-            if (this.__index >= child_count) {
-                return BehaviorStatus.Failed;
-            }
-
-            //initialize new child
-            const next = children[this.__index];
-
-            child.finalize();
-            next.initialize(this.context);
-        }
-
-        //we should never reach this point
-        return BehaviorStatus.Invalid;
-    }
-
-    finalize() {
-        super.finalize();
-
-        if (this.__children.length > 0) {
-            const b = this.__children[this.__index];
-
-            b.finalize();
-        }
-    }
-
-
-    initialize(context) {
-        super.initialize(context);
-
-        this.__index = 0;
-
-        if (this.__children.length > 0) {
-            this.__children[0].initialize(context);
-        }
-    }
-
-}