@woosh/meep-engine 2.43.39 → 2.43.42

package/engine/intelligence/behavior/behavior_to_dot.prototype.js

@@ -0,0 +1,55 @@
+import { SequenceBehavior } from "./composite/SequenceBehavior.js";
+import { SucceedingBehavior } from "./primitive/SucceedingBehavior.js";
+import { Behavior } from "./Behavior.js";
+import { ParallelBehavior } from "./composite/ParallelBehavior.js";
+import { behavior_to_dot } from "./behavior_to_dot.js";
+import { DelayBehavior } from "./util/DelayBehavior.js";
+
+
+class CenterCameraOnObject extends Behavior{
+    object = "whiteboard"
+}
+
+class UserControlsDisable extends  Behavior{
+
+}
+
+class PlayVideoInPopup extends  Behavior{
+    url = "url/how_to_use_whiteboard.mp4"
+}
+
+class DrawCurvesOnWhiteBoard extends Behavior{
+    curve = "hello"
+
+}
+
+class UserControlsEnable extends Behavior{
+
+}
+
+const complex = SequenceBehavior.from([
+    new SucceedingBehavior(),
+    SequenceBehavior.from([
+        new Behavior()
+    ]),
+    ParallelBehavior.from([
+        new SucceedingBehavior(),
+        DelayBehavior.from(17)
+    ])
+]);
+
+const tutorial = SequenceBehavior.from([ // will execute all members one after another
+
+    ParallelBehavior.from([ // will execute all members at the same time, completes when last member completes
+
+        new CenterCameraOnObject( ), // center camera on whiteboard
+        new UserControlsDisable(),
+        new PlayVideoInPopup() // plays a video in a popup, behavior finishes when video does
+
+    ]),
+    new DrawCurvesOnWhiteBoard(),
+    new UserControlsEnable()
+
+])
+
+console.log(behavior_to_dot(tutorial));

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

@@ -54,3 +54,9 @@ export class CompositeBehavior extends Behavior {
         this.__children = [];
     }
 }
+
+/**
+ *
+ * @type {boolean}
+ */
+CompositeBehavior.prototype.isCompositeBehavior = true;

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

@@ -226,5 +226,15 @@ export class ParallelBehavior extends CompositeBehavior {
     }
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParallelBehavior.prototype.isParallelBehavior = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
 ParallelBehavior.typeName = "ParallelBehavior";
 

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

@@ -1,9 +1,6 @@
 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 { assert } from "../../../../core/assert.js";
 
 export class SequenceBehavior extends CompositeBehavior {
@@ -115,52 +112,11 @@ export class SequenceBehavior extends CompositeBehavior {
     }
 }
 
-SequenceBehavior.typeName = "SequenceBehavior";
-
-export class SequenceBehaviorSerializationAdapter extends ObjectBasedClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = SequenceBehavior;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SequenceBehavior} value
-     */
-    serialize(buffer, value) {
-        const children = value.getChildren();
-
-        const n = children.length;
-        buffer.writeUintVar(n);
-
-        for (let i = 0; i < n; i++) {
-            const behavior = children[i];
+/**
+ * @readonly
+ * @type {boolean}
+ */
+SequenceBehavior.prototype.isSequenceBehavior = true;
 
-            this.objectAdapter.serialize(buffer, behavior);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {SequenceBehavior} value
-     */
-    deserialize(buffer, value) {
-        const n = buffer.readUintVar();
-
-        value.clearChildren();
-
-        for (let i = 0; i < n; i++) {
-            /**
-             *
-             * @type {Behavior}
-             */
-            const behavior = this.objectAdapter.deserialize(buffer);
+SequenceBehavior.typeName = "SequenceBehavior";
 
-            value.addChild(behavior);
-        }
-    }
-}

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

@@ -0,0 +1,52 @@
+import {
+    ObjectBasedClassSerializationAdapter
+} from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { SequenceBehavior } from "./SequenceBehavior.js";
+
+export class SequenceBehaviorSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = SequenceBehavior;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {SequenceBehavior} value
+     */
+    serialize(buffer, value) {
+        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 {SequenceBehavior} value
+     */
+    deserialize(buffer, value) {
+        const n = buffer.readUintVar();
+
+        value.clearChildren();
+
+        for (let i = 0; i < n; i++) {
+            /**
+             *
+             * @type {Behavior}
+             */
+            const behavior = this.objectAdapter.deserialize(buffer);
+
+            value.addChild(behavior);
+        }
+    }
+}

package/engine/intelligence/behavior/selector/WeightedElement.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class WeightedElement {
 

package/engine/intelligence/blackboard/Blackboard.js

@@ -18,7 +18,7 @@ export class Blackboard extends AbstractBlackboard {
 
         /**
          *
-         * @type {Object<string,BlackboardValue>}
+         * @type {Object<BlackboardValue>}
          */
         this.data = {};
 
@@ -76,7 +76,16 @@ export class Blackboard extends AbstractBlackboard {
         return this.proxy;
     }
 
+    /**
+     *
+     * @param {string} name
+     * @param {DataType} type
+     * @return {boolean} true only if entry exists and matches type, or if supplied parameter type is set to "Any"
+     */
     contains(name, type) {
+        assert.isString(name, 'name');
+        assert.enum(type, DataType, 'type');
+
         const datum = this.data[name];
 
         if (datum === undefined) {
@@ -115,7 +124,7 @@ export class Blackboard extends AbstractBlackboard {
      * @param {RegExp} pattern
      */
     traverseWithPattern(pattern, visitor) {
-        assert.notEqual(pattern, undefined, 'pattern is undefined');
+        assert.defined(pattern, 'pattern');
         assert.ok(pattern instanceof RegExp, 'pattern is not a RegExp');
 
         this.traverse(function (name, value, type) {
@@ -133,33 +142,36 @@ export class Blackboard extends AbstractBlackboard {
      * @returns {T}
      */
     acquire(name, type, initialValue) {
-        assert.typeOf(name, 'string', 'name');
+        assert.isString(name, 'name');
+
+        let datum;
 
         if (this.data.hasOwnProperty(name)) {
             // property exists
-            const datum = this.data[name];
+            datum = this.data[name];
 
             if (type !== DataType.Any && datum.type !== type) {
                 throw new TypeError(`Value '${name}' exists, but is type(='${datum.type}'), expected type '${type}'`);
             }
 
-            datum.referenceCount++;
-
-            return datum.value;
         } else {
             //doesn't exist - create it
-            const blackboardValue = new BlackboardValue(type);
+            datum = new BlackboardValue(type);
+
+            const concrete_value = datum.value;
 
             if (initialValue !== undefined) {
-                blackboardValue.value.set(initialValue);
+                concrete_value.set(initialValue);
             }
 
-            this.data[name] = blackboardValue;
-
-            this.on.added.send4(name, blackboardValue.value.getValue(), type, this);
+            this.data[name] = datum;
 
-            return blackboardValue.value;
+            this.on.added.send4(name, concrete_value.getValue(), type, this);
         }
+
+        datum.referenceCount++;
+
+        return datum.value;
     }
 
     /**
@@ -230,7 +242,7 @@ export class Blackboard extends AbstractBlackboard {
             if (value_type === 'number') {
                 this.acquireNumber(propName, value).set(value);
             } else if (value_type === 'boolean') {
-                this.acquireNumber(propName, value).set(value);
+                this.acquireBoolean(propName, value).set(value);
             } else if (value_type === 'string') {
                 this.acquireString(propName, value).set(value);
             }

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

@@ -0,0 +1,62 @@
+import { Blackboard } from "./Blackboard.js";
+import { DataType } from "../../../core/parser/simple/DataType.js";
+
+test('"contains" method', () => {
+    const bb = new Blackboard();
+
+    expect(bb.contains('a', DataType.Any)).toBe(false);
+
+    bb.acquireNumber('a', 0);
+
+    expect(bb.contains('a', DataType.Number)).toBe(true);
+    expect(bb.contains('a', DataType.Any)).toBe(true);
+    expect(bb.contains('a', DataType.Boolean)).toBe(false);
+
+    expect(bb.contains('b', DataType.Number)).toBe(false);
+});
+
+
+test("entry is deleted after reset", () => {
+    const bb = new Blackboard();
+
+    bb.acquireNumber('a');
+
+    bb.reset();
+
+    expect(bb.contains('a', DataType.Number)).toBe(false);
+});
+
+test("entry is copied across when blackboard is copied", () => {
+    const a = new Blackboard();
+
+    a.acquireNumber('test', 7);
+
+    const b = new Blackboard();
+
+    b.copy(a);
+
+    expect(b.contains('test', DataType.Number)).toBe(true);
+    expect(b.acquireNumber('test').getValue()).toBe(7);
+});
+
+test("to/from JSON serialization consistency", () => {
+
+    const source = new Blackboard();
+
+    source.acquireNumber('count', 7.1);
+    source.acquireBoolean('flag', true);
+    source.acquireString('label', 'hello');
+
+    const target = new Blackboard();
+
+    target.fromJSON(source.toJSON());
+
+    expect(target.contains('count', DataType.Number)).toBe(true);
+    expect(target.acquireNumber('count').getValue()).toBe(7.1);
+
+    expect(target.contains('flag', DataType.Boolean)).toBe(true);
+    expect(target.acquireBoolean('flag').getValue()).toBe(true);
+
+    expect(target.contains('label', DataType.String)).toBe(true);
+    expect(target.acquireString('label').getValue()).toBe('hello');
+});

package/engine/intelligence/blackboard/{Blacboard.spec.js → BlackboardSerializationAdapter.spec.js}

@@ -1,4 +1,4 @@
-import { Blackboard} from "./Blackboard.js";
+import { Blackboard } from "./Blackboard.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import { BlackboardSerializationAdapter } from "./BlackboardSerializationAdapter.js";
 

package/engine/intelligence/mcts/README.md

@@ -0,0 +1,7 @@
+Monte-Carlo Tree Search simulation package
+
+Intended for development of AI features
+
+
+References:
+* https://en.wikipedia.org/wiki/Monte_Carlo_tree_search

package/engine/intelligence/optimization/RandomOptimizer.js

@@ -2,7 +2,8 @@ import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 
 /**
- * Hill climbing optimizer based on random moves
+ * Hill climbing optimizer based on testing random moves one move at a time, if overall fitness improves - that move is committed, otherwise it's rejected
+ * Very dumb, but quite effective. Requires very little code to write a competent optimizer, especially when state space is relatively small
  * @template S
  * @class
  */

package/engine/intelligence/resource/ResourceAllocationBid.js

@@ -12,10 +12,10 @@ export class ResourceAllocationBid {
      * @param {number} value
      */
     constructor(allocation, value) {
-        assert.notEqual(allocation, undefined, 'allocation is undefined');
-        assert.notEqual(allocation, null, 'allocation is null');
+        assert.defined(allocation, 'allocation');
+        assert.notNull(allocation, 'allocation');
 
-        assert.typeOf(value, 'number', 'value');
+        assert.isNumber(value, 'value');
 
         /**
          *

package/engine/intelligence/resource/ResourceAllocationSolver.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 
 /**
- *
+ * Sorting comparator
  * @param {ResourceAllocationBid} a
  * @param {ResourceAllocationBid} b
  * @returns {number}

package/engine/intelligence/resource/StrategicResourceAllocator.js

@@ -31,6 +31,8 @@ export class StrategicResourceAllocator {
      */
     addTacticalModule(module) {
         assert.defined(module, 'module');
+        assert.notNull(module, 'module');
+        assert.equal(module.isTacticalModule, true, 'module.TacticalModule !== true');
 
         this.modules.push(module);
     }
@@ -53,13 +55,13 @@ export class StrategicResourceAllocator {
             const moduleResults = this.modules.map(m => {
                 const promise = m.collectBids(resources);
 
-                assert.notEqual(promise, undefined, 'promise is undefined');
-                assert.notEqual(promise, null, 'promise is null');
-                assert.typeOf(promise.then, 'function', "promise.then");
+                assert.defined(promise, 'promise');
+                assert.notNull(promise, 'promise');
+                assert.isFunction(promise.then, "promise.then");
 
                 promise.then(moduleBids => {
 
-                    assert.ok(Array.isArray(moduleBids), `moduleBids expected to be an array, was something else (typeof='${typeof moduleBids}')`);
+                    assert.isArray(moduleBids, 'moduleBids');
 
                     moduleBids.forEach(b => bids.set(b, m));
 

package/engine/intelligence/resource/TacticalModule.js

@@ -12,3 +12,10 @@ export class TacticalModule {
         throw new Error('Method needs to be overridden');
     }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TacticalModule.prototype.isTacticalModule = true;

package/engine/knowledge/database/StaticKnowledgeDataTableDescriptor.js

@@ -31,12 +31,12 @@ export class StaticKnowledgeDataTableDescriptor {
      */
     static from(id, source, table) {
 
-        assert.typeOf(id,'string','id');
-        assert.typeOf(source,'string','source');
+        assert.isString(id, 'id');
+        assert.isString(source, 'source');
 
-        assert.defined(table,'table');
-        assert.notNull(table,'table');
-        assert.equal(table.isStaticKnowledgeDataTable, true,'table.isStaticKnowledgeDataTable !== true');
+        assert.defined(table, 'table');
+        assert.notNull(table, 'table');
+        assert.equal(table.isStaticKnowledgeDataTable, true, 'table.isStaticKnowledgeDataTable !== true');
 
 
         const r = new StaticKnowledgeDataTableDescriptor();

package/engine/navigation/grid/GridField.js

@@ -9,6 +9,7 @@ const blockValue = 255;
 /**
  * A kind of 2D data texture
  * @deprecated prefer using {@link Sampler2D} instead, as it's more versatile and has wider feature set
+ *
  * @param {Number} width
  * @param {Number} height
  * @constructor

package/engine/notify/NotificationLog.js

@@ -9,13 +9,13 @@ import { assert } from "../../core/assert.js";
 
 function NotificationLog() {
     /**
-     *
+     * @readonly
      * @type {List<Notification>}
      */
     this.elements = new List();
 
     /**
-     *
+     * Once number of entries in the log reaches this amount, the earliest entries will be removed to make space for new ones
      * @type {number}
      */
     this.maxLength = 1000;

package/engine/sound/ecs/emitter/SoundEmitter.js

@@ -19,7 +19,7 @@ import { interpolate_irradiance_smith } from "../../../../core/math/physics/irra
 import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { compareStrings } from "../../../../core/primitives/strings/compareStrings.js";
 import { compareNumbers } from "../../../../core/primitives/numbers/compareNumbers.js";
 

package/engine/sound/ecs/emitter/SoundTrack.js

@@ -3,7 +3,7 @@ import { SoundTrackFlags } from "./SoundTrackFlags.js";
 import { assert } from "../../../../core/assert.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { compareStrings } from "../../../../core/primitives/strings/compareStrings.js";
 import { compareNumbers } from "../../../../core/primitives/numbers/compareNumbers.js";
 

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.39",
+  "version": "2.43.42",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",