@woosh/meep-engine 2.43.40 → 2.43.43

package/engine/intelligence/blackboard/Blackboard.js

@@ -3,6 +3,8 @@ import { assert } from "../../../core/assert.js";
 import Signal from "../../../core/events/signal/Signal.js";
 import { BlackboardValue } from "./BlackboardValue.js";
 import { AbstractBlackboard } from "./AbstractBlackboard.js";
+import { make_blackboard_proxy } from "./make_blackboard_proxy.js";
+
 
 export class Blackboard extends AbstractBlackboard {
     constructor() {
@@ -18,54 +20,18 @@ export class Blackboard extends AbstractBlackboard {
 
         /**
          *
-         * @type {Object<string,BlackboardValue>}
+         * @type {Object<BlackboardValue>}
          */
         this.data = {};
 
         /**
          * @private
          */
-        this.proxy = new Proxy(this, {
-            /**
-             *
-             * @param target
-             * @param {string} p
-             * @param receiver
-             * @returns {*}
-             */
-            get(target, p, receiver) {
-                const data = target.data;
-
-                if (!data.hasOwnProperty(p)) {
-                    // property not found
-                    return undefined;
-                }
-
-                const blackboardValue = data[p];
-
-                const resolved_value = blackboardValue.value.getValue();
-
-                return resolved_value;
-            },
-            set(target, p, value, receiver) {
-
-
-                const blackboardValue = target.data[p];
-
-                if (blackboardValue === undefined) {
-                    // blackboard property not found
-                    return undefined;
-                }
-
-                blackboardValue.value.set(value);
-
-            },
-            ownKeys(target) {
-
-                return Reflect.ownKeys(target.data);
+        this.proxy = make_blackboard_proxy(this);
+    }
 
-            }
-        });
+    getKeys() {
+        return Reflect.ownKeys(this.data);
     }
 
     /**
@@ -76,7 +42,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 +90,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 +108,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 +208,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/blackboard/make_blackboard_proxy.js

@@ -0,0 +1,47 @@
+import DataType from "../../../core/parser/simple/DataType.js";
+import { computeDataTypeFromValue } from "../../../core/parser/simple/computeDataTypeFromValue.js";
+
+/**
+ * Given a blackboard, returns a Proxy instance, exposing blackboard attributes as plain JSON
+ * Useful for connecting blackboard to systems that are not explicitly designed to work with a blackboard
+ * @param {AbstractBlackboard} blackboard
+ * @returns {Proxy}
+ */
+export function make_blackboard_proxy(blackboard) {
+    return new Proxy(blackboard, {
+        /**
+         *
+         * @param target
+         * @param {string} p
+         * @param receiver
+         * @returns {*}
+         */
+        get(target, p, receiver) {
+
+            if (!target.contains(p, DataType.Any)) {
+                // property not found
+                return undefined;
+            }
+
+            const value_container = target.acquire(p, DataType.Any);
+
+            return value_container.getValue();
+        },
+        set(target, p, value, receiver) {
+
+            const dataType = computeDataTypeFromValue(value);
+
+            const value_container = target.acquire(p, dataType, value);
+
+            value_container.set(value);
+
+            // succeeded
+            return true;
+        },
+        ownKeys(target) {
+
+            return target.getKeys();
+
+        }
+    })
+}

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

@@ -0,0 +1,23 @@
+import { Blackboard } from "./Blackboard.js";
+import { make_blackboard_proxy } from "./make_blackboard_proxy.js";
+
+test("setters propagate", () => {
+    const bb = new Blackboard();
+
+    const proxy = make_blackboard_proxy(bb);
+
+    proxy.hello = 7;
+
+    expect(bb.acquireNumber('hello').getValue()).toBe(7);
+});
+
+
+test("getters propagate", () => {
+    const bb = new Blackboard();
+
+    bb.acquireNumber('hello').set(7);
+
+    const proxy = make_blackboard_proxy(bb);
+
+    expect(proxy.hello).toBe(7);
+});

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