@woosh/meep-engine 2.36.28 → 2.37.0

package/engine/intelligence/behavior/composite/ParallelBehaviorSerializationAdapter.js

@@ -0,0 +1,63 @@
+import {
+    ObjectBasedClassSerializationAdapter
+} from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { ParallelBehavior } from "./ParallelBehavior.js";
+
+export class ParallelBehaviorSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = ParallelBehavior;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParallelBehavior} value
+     */
+    serialize(buffer, value) {
+
+        buffer.writeUint8(value.getSuccessPolicy());
+        buffer.writeUint8(value.getFailurePolicy());
+
+        const children = value.getChildren();
+
+        const n = children.length;
+
+        buffer.writeUintVar(n);
+
+        for (let i = 0; i < n; i++) {
+            const behavior = children[i];
+
+            this.objectAdapter.serialize(buffer, behavior);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParallelBehavior} value
+     */
+    deserialize(buffer, value) {
+        const successPolicy = buffer.readUint8();
+        const failurePolicy = buffer.readUint8();
+
+        const count = buffer.readUintVar();
+
+        value.clearChildren();
+
+        for (let i = 0; i < count; i++) {
+            /**
+             *
+             * @type {Behavior}
+             */
+            const child = this.objectAdapter.deserialize(buffer);
+
+            value.addChild(child);
+        }
+
+        value.setFailurePolicy(failurePolicy);
+        value.setSuccessPolicy(successPolicy);
+    }
+}

package/engine/intelligence/behavior/composite/SequenceBehavior.js

@@ -1,7 +1,10 @@
 import { Behavior } from "../Behavior.js";
 import { CompositeBehavior } from "./CompositeBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
-import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import {
+    ObjectBasedClassSerializationAdapter
+} from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { assert } from "../../../../core/assert.js";
 
 export class SequenceBehavior extends CompositeBehavior {
     constructor() {
@@ -13,6 +16,12 @@ export class SequenceBehavior extends CompositeBehavior {
          * @protected
          */
         this.__currentBehaviourIndex = -1;
+        /**
+         *
+         * @type {BehaviorStatus|number}
+         * @private
+         */
+        this.__currentBehaviourState = BehaviorStatus.Initial;
 
         /**
          *
@@ -23,32 +32,41 @@ export class SequenceBehavior extends CompositeBehavior {
     }
 
     initialize(context) {
-
+        // console.log('+ SequenceBehavior');
         super.initialize(context);
 
         this.__currentBehaviourIndex = 0;
-        this.__currentBehaviour = this.__children[this.__currentBehaviourIndex];
+        this.__currentBehaviour = this.__children[0];
 
         //initialize first behaviour
         this.__currentBehaviour.initialize(context);
 
+        this.__currentBehaviourState = BehaviorStatus.Running;
     }
 
+
     /**
      *
      * @param {number} timeDelta
      * @returns {BehaviorStatus}
      */
     tick(timeDelta) {
-        const s = this.__currentBehaviour.tick(timeDelta);
+        assert.isNonNegativeInteger(this.__currentBehaviourIndex, 'child index');
+
+        const currentBehaviour = this.__currentBehaviour;
+
+        const s = currentBehaviour.tick(timeDelta);
+
+        this.__currentBehaviourState = s;
 
         if (s !== BehaviorStatus.Succeeded) {
             return s;
         }
 
         //current behaviour succeeded, move onto the next one
-        this.__currentBehaviour.finalize();
+        currentBehaviour.finalize();
 
+        this.__currentBehaviourState = BehaviorStatus.Initial;
         this.__currentBehaviourIndex++;
 
         if (this.__currentBehaviourIndex < this.__children.length) {
@@ -56,24 +74,31 @@ export class SequenceBehavior extends CompositeBehavior {
 
             this.__currentBehaviour.initialize(this.context);
 
+            this.__currentBehaviourState = BehaviorStatus.Running;
+
             return BehaviorStatus.Running;
         } else {
-            this.__status = BehaviorStatus.Succeeded;
-
             //all behaviours completed
-            return this.__status;
+            return BehaviorStatus.Succeeded;
         }
     }
 
     finalize() {
-        if (this.__currentBehaviourIndex !== this.__children.length) {
+
+        const child_count = this.__children.length;
+
+        if (this.__currentBehaviourIndex !== child_count) {
             //sequence has not been finished
 
-            if (this.__currentBehaviour !== undefined && this.__currentBehaviour.getStatus() !== BehaviorStatus.Initial) {
+            if (this.__currentBehaviour !== undefined && this.__currentBehaviourState !== BehaviorStatus.Initial) {
                 this.__currentBehaviour.finalize();
             }
         }
-        this.__status = BehaviorStatus.Initial;
+
+        this.__currentBehaviour = undefined;
+        this.__currentBehaviourIndex = child_count;
+
+        // console.warn('- SequenceBehavior');
     }
 
     /**

package/engine/intelligence/behavior/decorator/AbstractDecoratorBehavior.js

@@ -36,8 +36,6 @@ export class AbstractDecoratorBehavior extends Behavior {
     initialize(context) {
         super.initialize(context);
         this.__source.initialize(context);
-
-        this.__status = this.__source.getStatus();
     }
 
     finalize() {

package/engine/intelligence/behavior/decorator/IgnoreFailureBehavior.js

@@ -19,11 +19,9 @@ export class IgnoreFailureBehavior extends AbstractDecoratorBehavior {
         const behaviorStatus = this.__source.tick(timeDelta);
 
         if (behaviorStatus === BehaviorStatus.Failed) {
-            this.setStatus(BehaviorStatus.Succeeded);
-        } else {
-            this.setStatus(behaviorStatus);
+            return BehaviorStatus.Succeeded;
         }
 
-        return this.getStatus();
+        return behaviorStatus;
     }
 }

package/engine/intelligence/behavior/decorator/InverterBehavior.js

@@ -1,6 +1,8 @@
 import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
-import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import {
+    ObjectBasedClassSerializationAdapter
+} from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
 import { AbstractDecoratorBehavior } from "./AbstractDecoratorBehavior.js";
 
 /**
@@ -37,8 +39,6 @@ export class InverterBehavior extends AbstractDecoratorBehavior {
             r = BehaviorStatus.Succeeded;
         }
 
-        this.__status = r;
-
         return r;
     }
 }

package/engine/intelligence/behavior/decorator/RepeatBehavior.js

@@ -1,6 +1,5 @@
 import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
-import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
 import { AbstractDecoratorBehavior } from "./AbstractDecoratorBehavior.js";
 import { assert } from "../../../../core/assert.js";
 
@@ -65,7 +64,6 @@ export class RepeatBehavior extends AbstractDecoratorBehavior {
         assert.enum(s, BehaviorStatus, 'status');
 
         if (s !== BehaviorStatus.Succeeded && s !== BehaviorStatus.Failed) {
-            this.__status = s;
             return s;
         }
 
@@ -73,7 +71,6 @@ export class RepeatBehavior extends AbstractDecoratorBehavior {
         this.__iterator++;
 
         if (this.__iterator >= this.__limit) {
-            this.__status = BehaviorStatus.Succeeded;
 
             return BehaviorStatus.Succeeded;
         } else {
@@ -87,35 +84,3 @@ export class RepeatBehavior extends AbstractDecoratorBehavior {
 
 RepeatBehavior.typeName = "RepeatBehavior";
 
-export class RepeatBehaviorSerializationAdapter extends ObjectBasedClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = RepeatBehavior;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {RepeatBehavior} value
-     */
-    serialize(buffer, value) {
-        buffer.writeUintVar(value.getCount());
-
-        this.objectAdapter.serialize(buffer, value.getSource());
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {RepeatBehavior} value
-     */
-    deserialize(buffer, value) {
-        const count = buffer.readUintVar();
-        const source = this.objectAdapter.deserialize(buffer);
-
-        value.setCount(count);
-        value.setSource(source);
-    }
-}

package/engine/intelligence/behavior/decorator/RepeatBehavior.spec.js

@@ -6,11 +6,7 @@ import { jest } from '@jest/globals';
 test("initialization", () => {
     const b = new RepeatBehavior(new SucceedingBehavior(), 1);
 
-    expect(b.getStatus()).toBe(BehaviorStatus.Initial);
-
     b.initialize();
-
-    expect(b.getStatus()).toBe(BehaviorStatus.Running);
 });
 
 test('2 successful repetitions', () => {
@@ -23,12 +19,8 @@ test('2 successful repetitions', () => {
 
     b.initialize();
 
-    expect(b.getStatus()).toBe(BehaviorStatus.Running);
-
     expect(b.tick(3)).toBe(BehaviorStatus.Running);
 
-    expect(b.getStatus()).toBe(BehaviorStatus.Running);
-
     expect(tickSpy).toHaveBeenCalledTimes(1);
     expect(tickSpy).toHaveBeenCalledWith(3);
 
@@ -37,6 +29,4 @@ test('2 successful repetitions', () => {
 
     expect(tickSpy).toHaveBeenCalledTimes(2);
     expect(tickSpy).toHaveBeenLastCalledWith(7);
-
-    expect(b.getStatus()).toBe(BehaviorStatus.Succeeded);
 });

package/engine/intelligence/behavior/decorator/RepeatBehaviorSerializationAdapter.js

@@ -0,0 +1,37 @@
+import {
+    ObjectBasedClassSerializationAdapter
+} from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { RepeatBehavior } from "./RepeatBehavior.js";
+
+export class RepeatBehaviorSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = RepeatBehavior;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RepeatBehavior} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUintVar(value.getCount());
+
+        this.objectAdapter.serialize(buffer, value.getSource());
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RepeatBehavior} value
+     */
+    deserialize(buffer, value) {
+        const count = buffer.readUintVar();
+        const source = this.objectAdapter.deserialize(buffer);
+
+        value.setCount(count);
+        value.setSource(source);
+    }
+}

package/engine/intelligence/behavior/decorator/RepeatUntilFailureBehavior.js

@@ -51,8 +51,6 @@ export class RepeatUntilFailureBehavior extends AbstractDecoratorBehavior {
 
         if (s !== BehaviorStatus.Succeeded) {
 
-            this.__status = s;
-
             return s;
 
         }
@@ -60,7 +58,6 @@ export class RepeatUntilFailureBehavior extends AbstractDecoratorBehavior {
         this.__iterator++;
 
         if (this.__iterator >= this.__limit) {
-            this.__status = BehaviorStatus.Succeeded;
 
             return BehaviorStatus.Succeeded;
         } else {

package/engine/intelligence/behavior/decorator/RepeatUntilSuccessBehavior.js

@@ -40,10 +40,10 @@ export class RepeatUntilSuccessBehavior extends AbstractDecoratorBehavior {
      * @return {RepeatUntilSuccessBehavior}
      */
     static from(source, limit = Infinity) {
-        const r = new RepeatUntilSuccessBehavior();
-
-        r.setSource(source);
-        r.__limit = limit;
+        const r = new RepeatUntilSuccessBehavior(
+            source,
+            limit
+        );
 
         return r;
     }
@@ -52,9 +52,6 @@ export class RepeatUntilSuccessBehavior extends AbstractDecoratorBehavior {
         const s = this.__source.tick(timeDelta);
 
         if (s === BehaviorStatus.Succeeded) {
-
-            this.__status = s;
-
             return s;
 
         } else if (s === BehaviorStatus.Running) {
@@ -64,9 +61,7 @@ export class RepeatUntilSuccessBehavior extends AbstractDecoratorBehavior {
         this.__iterator++;
 
         if (this.__iterator >= this.__limit) {
-            this.__status = BehaviorStatus.Failed;
-
-            return this.__status;
+            return BehaviorStatus.Failed;
         } else {
             //re-initialize the source behavior
             this.__source.initialize(this.context);

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

@@ -2,18 +2,15 @@ import { assert } from "../../../../core/assert.js";
 import { ClockChannelType } from "./ClockChannelType.js";
 import { RepeatBehavior } from "../decorator/RepeatBehavior.js";
 import { ActionBehavior } from "../primitive/ActionBehavior.js";
+import { SequenceBehavior } from "../composite/SequenceBehavior.js";
 
 export const BehaviorComponentFlag = {
-    AllowSleep: 1
+    AllowSleep: 1,
+    Resolved: 2
 };
 
 export class BehaviorComponent {
     constructor() {
-        /**
-         *
-         * @type {Behavior[]}
-         */
-        this.list = [];
 
         /**
          *
@@ -26,6 +23,97 @@ export class BehaviorComponent {
          * @type {number}
          */
         this.flags = 0;
+
+        /**
+         *
+         * @type {Behavior|null}
+         * @private
+         */
+        this.__behavior = null;
+    }
+
+    /**
+     *
+     * @param {number|BehaviorComponentFlag} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|BehaviorComponentFlag} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|BehaviorComponentFlag} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|BehaviorComponentFlag} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+    /**
+     *
+     * @returns {Behavior|null}
+     */
+    get behavior() {
+        return this.__behavior;
+    }
+
+    /**
+     *
+     * @param {Behavior} v
+     */
+    set behavior(v) {
+        this.__behavior = v;
+    }
+
+    /**
+     * @deprecated
+     * @returns {Readonly<Behavior[]>}
+     */
+    get list() {
+        if (this.__behavior !== null) {
+            return [this.__behavior];
+        } else {
+            return [];
+        }
+    }
+
+    /**
+     * @deprecated
+     * @param {Behavior[]} v
+     */
+    set list(v) {
+        console.warn('.list is deprecated, use SequenceBehavior instead');
+        if (v.length > 1) {
+            console.warn('.list is deprecated, converting to sequence instead');
+            this.__behavior = SequenceBehavior.from(v);
+        } else if (v.length === 1) {
+            this.__behavior = v[0];
+        } else {
+            this.__behavior = null;
+        }
     }
 
 
@@ -53,7 +141,7 @@ export class BehaviorComponent {
 
         const result = new BehaviorComponent();
 
-        result.list.push(b);
+        result.__behavior = b;
 
         return result;
 

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

@@ -1,5 +1,7 @@
 import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { BehaviorComponent } from "./BehaviorComponent.js";
+import { SequenceBehavior } from "../composite/SequenceBehavior.js";
+import { SucceedingBehavior } from "../primitive/SucceedingBehavior.js";
 
 export class BehaviorComponentSerializationAdapter extends BinaryClassSerializationAdapter {
     constructor() {
@@ -33,15 +35,13 @@ export class BehaviorComponentSerializationAdapter extends BinaryClassSerializat
         buffer.writeUint8(value.clock);
         buffer.writeUint8(value.flags);
 
-        const behaviors = value.list;
-        const n = behaviors.length;
-        buffer.writeUintVar(n);
-
-        for (let i = 0; i < n; i++) {
-            const behavior = behaviors[i];
+        if (value.behavior !== null) {
+            buffer.writeUintVar(1);
 
             //write single behavior
-            this.objectAdapter.serialize(buffer, behavior);
+            this.objectAdapter.serialize(buffer, value.behavior);
+        } else {
+            buffer.writeUintVar(0);
         }
     }
 
@@ -71,6 +71,13 @@ export class BehaviorComponentSerializationAdapter extends BinaryClassSerializat
         //write object fields
         value.clock = clock;
         value.flags = flags;
-        value.list = behaviors;
+
+        if (behaviors.length > 1) {
+            value.behavior = SequenceBehavior.from(behaviors);
+        } else if (behaviors.length === 1) {
+            value.behavior = behaviors[0];
+        } else {
+            value.behavior = SucceedingBehavior.from(0);
+        }
     }
 }

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

@@ -1,25 +1,25 @@
 import { System } from "../../../ecs/System.js";
-import { BehaviorComponent } from "./BehaviorComponent.js";
+import { BehaviorComponent, BehaviorComponentFlag } from "./BehaviorComponent.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import Clock from "../../../Clock.js";
 import { ClockChannelType } from "./ClockChannelType.js";
 
 /**
  *
- * @param {BehaviorStatus} behavior
+ * @param {Behavior} behavior
  * @param {number} timeDelta
+ * @returns {BehaviorStatus}
  */
 function updateBehavior(behavior, timeDelta) {
 
     try {
-        behavior.tick(timeDelta);
+        return behavior.tick(timeDelta);
     } catch (e) {
         console.error('Behavior threw an exception', e);
 
         // Transition behavior into failed state
-        behavior.setStatus(BehaviorStatus.Failed);
+        return BehaviorStatus.Failed;
     }
-
 }
 
 export class BehaviorSystem extends System {
@@ -60,24 +60,18 @@ export class BehaviorSystem extends System {
      * @param {number} entity
      */
     link(component, entity) {
+        const behavior = component.behavior;
+        component.clearFlag(BehaviorComponentFlag.Resolved);
 
-        const list = component.list;
-        const l = list.length;
-
-        for (let i = 0; i < l; i++) {
-            const behavior = list[i];
-
-            if (behavior.getStatus() === BehaviorStatus.Initial) {
-                // initialize behavior
-                const dataset = this.entityManager.dataset;
+        if (behavior !== null) {
 
-                try {
-                    behavior.initialize({ entity, ecd: dataset, engine: this.engine });
-                } catch (e) {
-                    console.warn('Behavior initialization failed:', e);
+            // initialize behavior
+            const dataset = this.entityManager.dataset;
 
-                    behavior.setStatus(BehaviorStatus.Failed);
-                }
+            try {
+                behavior.initialize({ entity, ecd: dataset, engine: this.engine });
+            } catch (e) {
+                console.warn('Behavior initialization failed:', e);
             }
         }
     }
@@ -88,17 +82,12 @@ export class BehaviorSystem extends System {
      * @param {number} entity
      */
     unlink(component, entity) {
+        const behavior = component.behavior;
 
-        const list = component.list;
-        const l = list.length;
-
-        for (let i = 0; i < l; i++) {
-            const behavior = list[i];
+        if (behavior !== null) {
 
-            if (behavior.getStatus() === BehaviorStatus.Running) {
-                // finalize behavior
-                behavior.finalize();
-            }
+            // finalize behavior
+            behavior.finalize();
         }
     }
 
@@ -118,8 +107,9 @@ export class BehaviorSystem extends System {
          * @param {number} entity
          */
         function visitBehavior(b, entity) {
-            const list = b.list;
-            const l = list.length;
+            if (b.getFlag(BehaviorComponentFlag.Resolved)) {
+                return;
+            }
 
             let td;
 
@@ -131,15 +121,16 @@ export class BehaviorSystem extends System {
                 td = systemDelta;
             }
 
-            for (let i = 0; i < l; i++) {
-                const behavior = list[i];
+            const behavior = b.behavior;
 
-                if (behavior.getStatus() !== BehaviorStatus.Running) {
-                    continue;
-                }
+            if (behavior !== null) {
+                const state = updateBehavior(behavior, td);
 
-                updateBehavior(behavior, td);
+                if (state === BehaviorStatus.Failed || state === BehaviorStatus.Succeeded) {
+                    b.setFlag(BehaviorComponentFlag.Resolved);
+                }
             }
+
         }
 
         dataset.traverseComponents(BehaviorComponent, visitBehavior);