@woosh/meep-engine 2.46.30 → 2.46.31

package/package.json

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

package/src/engine/intelligence/behavior/composite/CompositeBehavior.js

@@ -1,6 +1,9 @@
 import { Behavior } from "../Behavior.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Abstract class
+ */
 export class CompositeBehavior extends Behavior {
     constructor() {
         super();
@@ -18,12 +21,25 @@ export class CompositeBehavior extends Behavior {
      * @param {Behavior} child
      */
     addChild(child) {
-        assert.defined(child);
-        assert.ok(child.isBehavior, 'child is not a Behavior');
+        assert.defined(child, 'child');
+        assert.notNull(child, 'child');
+        assert.equal(child.isBehavior, true, 'child is not a Behavior');
 
         this.__children.push(child);
     }
 
+    /**
+     *
+     * @param {Behavior[]} many
+     */
+    addChildren(many) {
+        const n = many.length;
+        for (let i = 0; i < n; i++) {
+            const e = many[i];
+            r.addChild(e);
+        }
+    }
+
     /**
      * NOTE: do not modify obtained value
      * @return {Behavior[]}

package/src/engine/intelligence/behavior/composite/ParallelBehavior.js

@@ -1,6 +1,7 @@
 import { CompositeBehavior } from "./CompositeBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { BitSet } from "../../../../core/binary/BitSet.js";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -11,6 +12,9 @@ export const ParallelBehaviorPolicy = {
     RequireAll: 1
 };
 
+/**
+ * Executes all contained behaviors in parallel
+ */
 export class ParallelBehavior extends CompositeBehavior {
     /**
      *
@@ -20,6 +24,9 @@ export class ParallelBehavior extends CompositeBehavior {
     constructor(successPolicy, failurePolicy) {
         super();
 
+        assert.enum(successPolicy, ParallelBehaviorPolicy, 'successPolicy');
+        assert.enum(failurePolicy, ParallelBehaviorPolicy, 'failurePolicy');
+
         /**
          * @private
          * @type {ParallelBehaviorPolicy}
@@ -33,6 +40,7 @@ export class ParallelBehavior extends CompositeBehavior {
         this.failurePolicy = failurePolicy;
 
         /**
+         * @readonly
          * @private
          * @type {BitSet}
          */
@@ -60,10 +68,11 @@ export class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setSuccessPolicy(v) {
-        this.successPolicy = v;
+    setSuccessPolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.successPolicy = policy;
     }
 
     /**
@@ -76,10 +85,11 @@ export class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setFailurePolicy(v) {
-        this.failurePolicy = v;
+    setFailurePolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.failurePolicy = policy;
     }
 
     /**
@@ -213,14 +223,16 @@ export class ParallelBehavior extends CompositeBehavior {
     /**
      *
      * @param {Behavior[]} elements
-     * @param {ParallelBehaviorPolicy} success
-     * @param {ParallelBehaviorPolicy} failure
+     * @param {ParallelBehaviorPolicy} success how should successful completion be determined?
+     * @param {ParallelBehaviorPolicy} failure how should failing completion be determined
      * @returns {ParallelBehavior}
      */
     static from(elements, success = ParallelBehaviorPolicy.RequireAll, failure = ParallelBehaviorPolicy.RequireOne) {
+        assert.isArray(elements, 'elements');
+
         const r = new ParallelBehavior(success, failure);
 
-        elements.forEach(e => r.addChild(e));
+        r.addChildren(elements);
 
         return r;
     }

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

@@ -3,6 +3,10 @@ import { CompositeBehavior } from "./CompositeBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Executes all contained behaviors one after another in a sequence, next behaviour in the sequence will not be started until the previous one signal success
+ * If any of the contained behaviours fail - the whole sequence fails
+ */
 export class SequenceBehavior extends CompositeBehavior {
     constructor() {
         super();
@@ -106,7 +110,7 @@ export class SequenceBehavior extends CompositeBehavior {
     static from(list) {
         const r = new SequenceBehavior();
 
-        list.forEach(b => r.addChild(b));
+        r.addChildren(list);
 
         return r;
     }

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

@@ -2,12 +2,15 @@ import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Wait for a certain amount of time
+ */
 export class DelayBehavior extends Behavior {
     constructor() {
         super();
 
         /**
-         * Delay value
+         * Delay value in seconds
          * @type {number}
          */
         this.value = 0;
@@ -38,11 +41,13 @@ export class DelayBehavior extends Behavior {
 
     /**
      *
-     * @param {number} value
+     * @param {number} value in seconds
      * @return {DelayBehavior}
      */
     static from(value) {
-        assert.typeOf(value, 'number', 'value');
+        assert.isNumber(value,  'value');
+        assert.notNaN(value,'value');
+        assert.isFiniteNumber(value,'value');
 
         const r = new DelayBehavior();