@woosh/meep-engine 2.43.40 → 2.43.42

package/engine/intelligence/behavior/behavior_to_dot.js

@@ -0,0 +1,251 @@
+import LineBuilder from "../../../core/codegen/LineBuilder.js";
+import { Behavior } from "./Behavior.js";
+
+/**
+ *
+ * @param {Behavior} behavior
+ * @return {string}
+ */
+function compute_behavior_name(behavior) {
+
+    // try to get name from the constructor field
+    const typeName = behavior.constructor.typeName;
+    if (typeof typeName === "string") {
+        return typeName;
+    }
+
+    const constructor_name = behavior.constructor.name;
+    if (typeof constructor_name === "string") {
+        return constructor_name;
+    }
+
+    return '$Behavior';
+}
+
+
+/**
+ *
+ * @param {Behavior|SequenceBehavior|ParallelBehavior} behavior
+ * @return {Object}
+ */
+function behavior_node_attributes(behavior) {
+    const result = {};
+
+    if (behavior.isCompositeBehavior === true) {
+
+        result.fillcolor = "orange";
+
+        if (behavior.isSequenceBehavior === true) {
+            result.fillcolor = "paleturquoise";
+        } else if (behavior.isParallelBehavior === true) {
+            result.fillcolor = "plum";
+        }
+    } else {
+
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {Object} attributes
+ * @return {string}
+ */
+function attributes_to_dot(attributes) {
+    const key_names = Object.keys(attributes);
+
+    return key_names.map(key => {
+
+        return `${key}=${attributes[key]}`;
+
+    }).join(', ');
+}
+
+/**
+ *
+ * @param {string} prop
+ * @param {Object} object
+ */
+function should_property_be_included(prop, object) {
+    if (prop.startsWith('_')) {
+        // private field
+        return false;
+    }
+
+    const value = object[prop];
+
+    if (object.constructor.prototype[prop] === value) {
+        return false;
+    }
+
+    const typeof_value = typeof value;
+
+    if (value === null || typeof_value === "undefined" || typeof_value === "symbol") {
+        return false;
+    }
+
+    if (typeof_value === "object" && String(value) === '[object Object]') {
+        return false;
+    }
+
+    return true;
+}
+
+function property_to_string(value, max_length = 200) {
+
+
+    let string_value;
+
+    if (typeof value !== "string") {
+        string_value = String(value);
+    } else {
+        string_value = `\"${value}\"`;
+    }
+
+    const sanitized = string_value.replace(/\n/, "\n");
+
+    if (sanitized.length > max_length) {
+        return '[...]';
+    }
+
+    return sanitized;
+}
+
+/**
+ *
+ * @param {Behavior} behavior
+ * @param {number} max_props
+ */
+function build_node_properties_string(behavior, max_props = 10) {
+
+    const properties = {};
+
+    let qualified_property_count = 0;
+
+    for (const behaviorKey in behavior) {
+
+        if (should_property_be_included(behaviorKey, behavior)) {
+            if (qualified_property_count < max_props) {
+                properties[behaviorKey] = property_to_string(behavior[behaviorKey]);
+            }
+
+            qualified_property_count++;
+        }
+
+    }
+
+    // stringify and concatenate
+    return Object.keys(properties).map(key => `${key} = ${properties[key]}`).join('<BR/>');
+
+}
+
+/**
+ *
+ * @param {Behavior} behavior
+ * @return {boolean}
+ */
+function should_behavior_have_properties_string(behavior) {
+    if (behavior.isCompositeBehavior === true) {
+        return false;
+    }
+
+    return true;
+}
+
+function build_node_label(behavior) {
+    const node_name = compute_behavior_name(behavior);
+
+    const label_pieces = [];
+
+    label_pieces.push(`<B>${node_name}</B>`);
+
+    if (should_behavior_have_properties_string(behavior)) {
+        const properties = build_node_properties_string(behavior);
+
+        if (properties.trim().length > 0) {
+
+            label_pieces.push(properties);
+
+        }
+    }
+
+    return `<{ {${label_pieces.join('<BR/>')} } }>`;
+}
+
+/**
+ *
+ * @param {LineBuilder} out
+ * @param {Behavior|CompositeBehavior} behavior
+ * @param {{id_counter:number, node_ids:Map<Behavior,string>}} context
+ * @returns {string}
+ */
+function parse_behavior(out, behavior, context) {
+    const id = context.id_counter++;
+    const node_id = `Node_${id}`;
+
+    context.node_ids.set(behavior, node_id);
+
+    const attributes = {
+        label: build_node_label(behavior),
+        style: "\"rounded,filled\""
+    };
+
+    Object.assign(attributes, behavior_node_attributes(behavior));
+
+    out.add(`${node_id} [${attributes_to_dot(attributes)}]`);
+
+    if (behavior.isCompositeBehavior === true) {
+        // is a composite behavior, which means it includes other behaviors
+
+        const children = behavior.getChildren();
+
+        const child_count = children.length;
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            const child_id = parse_behavior(out, child, context);
+
+            // create edge
+            out.add(`${node_id} -> ${child_id} [label="№${i + 1}"];`);
+        }
+
+    }
+
+    return node_id;
+}
+
+/**
+ * Produces a diagram of behavior tree in DOT format, useful for debugging and exploration of complex trees
+ *
+ * @see https://en.wikipedia.org/wiki/DOT_(graph_description_language)
+ * @param {Behavior} behavior
+ * @returns {string}
+ */
+export function behavior_to_dot(behavior) {
+    const out = new LineBuilder();
+
+    const context = {
+        id_counter: 0,
+        node_ids: new Map()
+    };
+
+    const font = {
+        name: "helvetica",
+        size: 10
+    };
+
+    out.add("digraph BehaviorTree {");
+    out.indent();
+    out.add("graph [style=invis, rankdir=\"TB\" ordering=out, splines=spline]");
+    out.add(`node [shape=record, fontname=\"${font.name}\", fontsize=${font.size}, margin=\"0.2,0.03\", fillcolor=ivory]`);
+    out.add(`edge [labelfontname=\"${font.name}\", labelfontsize=${font.size}, fontname=\"${font.name}\", fontsize=${font.size}, fontcolor=grey]`);
+
+    parse_behavior(out, behavior, context);
+
+    out.dedent();
+    out.add("}");
+
+    return out.build();
+}

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/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));