@woosh/meep-engine 2.49.4 → 2.49.7

package/package.json

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

package/src/core/cache/LoadingCache.d.ts

@@ -1,18 +1,21 @@
-export declare class LoadingCache<K,V>{
-    constructor(options:{
+export declare class LoadingCache<K, V> {
+    constructor(options: {
         maxWeight?: number,
         keyWeigher?: (key: K) => number,
         valueWeigher?: (value: V) => number,
         keyHashFunction?: (key: K) => number,
         keyEqualityFunction?: (a: K, b: K) => boolean,
         capacity?: number,
-        timeToLive?:number,
-        load:(key:K)=> Promise<V>
+        timeToLive?: number,
+        load: (key: K) => Promise<V>,
+        retryFailed?: boolean
     })
 
-    invalidate(key:K):void
+    refresh(key: K): Promise<V>
 
-    clear():void
+    invalidate(key: K): void
 
-    get(key:K):Promise<V>
+    clear(): void
+
+    get(key: K): Promise<V>
 }

package/src/core/cache/LoadingCache.js

@@ -3,20 +3,25 @@
 import { Cache } from "./Cache.js";
 
 /**
- * @template {V}
+ * @template R
  */
 class Record {
     /**
-     *
-     * @param {V} value
+     * @template R
+     * @param {R} value
      * @param {number} time
      */
     constructor(value, time) {
         this.value = value;
         this.time = time;
+        this.failed = false;
     }
 }
 
+function current_time_in_seconds() {
+    return performance.now() * 1e-3;
+}
+
 const DEFAULT_TIME_TO_LIVE = 10;
 
 /**
@@ -38,6 +43,12 @@ export class LoadingCache {
      */
     #load
 
+    /**
+     *
+     * @type {boolean}
+     */
+    #policyRetryFailed = true;
+
     /**
      * @see {@link Cache} for more details on what each parameter means
      * @param maxWeight
@@ -48,6 +59,7 @@ export class LoadingCache {
      * @param capacity
      * @param {number} [timeToLive] in seconds
      * @param load
+     * @param {boolean} [retryFailed]
      */
     constructor({
                     maxWeight,
@@ -57,7 +69,8 @@ export class LoadingCache {
                     keyEqualityFunction,
                     capacity,
                     timeToLive = DEFAULT_TIME_TO_LIVE,
-                    load
+                    load,
+                    retryFailed = true
                 }) {
 
         this.#internal = new Cache({
@@ -71,6 +84,7 @@ export class LoadingCache {
 
         this.#timeToLive = timeToLive;
         this.#load = load;
+        this.#policyRetryFailed = retryFailed;
     }
 
     /**
@@ -88,24 +102,66 @@ export class LoadingCache {
         this.#internal.clear();
     }
 
+    /**
+     *
+     * @param {K} key
+     * @param {number} timestamp
+     * @return {Record<Promise<V>>}
+     */
+    #load_value(key, timestamp) {
+
+        let promise;
+
+        try {
+            promise = this.#load(key);
+        } catch (e) {
+            promise = Promise.reject(e);
+        }
+
+        const record = new Record(promise, timestamp);
+
+        this.#internal.put(key, record);
+
+        promise.catch(() => {
+            // mark as failure
+            record.failed = true;
+        });
+
+        return record;
+    }
+
+    /**
+     * Load new value for the key (happens asynchronously)
+     * @param {K} key
+     * @returns {Promise<V>}
+     */
+    refresh(key) {
+        const record = this.#load_value(key, current_time_in_seconds());
+
+        return record.value;
+    }
+
     /**
      *
      * @param {K} key
      * @return {Promise<V>}
      */
     async get(key) {
-        const currentTime = performance.now() * 1e-3;
+        const currentTime = current_time_in_seconds();
 
+        /**
+         *
+         * @type {Record<Promise<V>>}
+         */
         let record = this.#internal.get(key);
 
-        if (record === null || (record.time + this.#timeToLive) < currentTime) {
-
-            // missing or stale record
-            const promise = this.#load(key);
-
-            record = new Record(promise, currentTime);
+        if (record === null
+            || (record.time + this.#timeToLive) < currentTime  // timeout
+            || (record.failed && this.#policyRetryFailed) // load failed and we're configured to retry
+        ) {
 
-            this.#internal.put(key, record);
+            // record needs to be loaded
+            record = this.#load_value(key, currentTime);
 
         }
 

package/src/core/cache/LoadingCache.spec.js

@@ -0,0 +1,47 @@
+import { LoadingCache } from "./LoadingCache.js";
+import { delay } from "../process/delay.js";
+
+test("successful load", async () => {
+    const cache = new LoadingCache({
+        async load(key) {
+            return 17;
+        }
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+});
+
+test("record reuse", async () => {
+    const load = jest.fn(async () => 17);
+
+    const cache = new LoadingCache({
+        load
+    });
+
+    expect(await cache.get(1)).toEqual(17);
+    expect(await cache.get(1)).toEqual(17);
+
+    expect(load).toHaveBeenCalledTimes(1);
+});
+
+test("timeout reload reuse", async () => {
+
+    const values = [3, 5, 11];
+
+    const load = jest.fn(async () => values.pop());
+
+    const cache = new LoadingCache({
+        load,
+        timeToLive: 0.00001
+    });
+
+    expect(await cache.get(1)).toEqual(11);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(5);
+
+    await delay(1);
+
+    expect(await cache.get(1)).toEqual(3);
+});

package/src/core/math/computeGreatestCommonDivisor.spec.js

@@ -0,0 +1,9 @@
+import { computeGreatestCommonDivisor } from "./computeGreatestCommonDivisor.js";
+
+test("1 and 1", () => {
+    expect(computeGreatestCommonDivisor(1, 1)).toBe(1);
+});
+
+test("6 and 9", () => {
+    expect(computeGreatestCommonDivisor(6, 9)).toBe(3);
+});

package/src/core/math/statistics/computeStatisticalMean.spec.js

@@ -0,0 +1,9 @@
+import { computeStatisticalMean } from "./computeStatisticalMean.js";
+
+test("from just 1 item", () => {
+    expect(computeStatisticalMean([-7])).toEqual(-7)
+});
+
+test("from 2 items", () => {
+    expect(computeStatisticalMean([-7, 17])).toEqual(5)
+});

package/src/core/math/statistics/halton_sequence.spec.js

@@ -5,7 +5,12 @@ test("unique values in base 10", () => {
     const values = [];
 
     for (let i = 0; i < 10; i++) {
-        values.push(halton_sequence(10, i));
+        const v = halton_sequence(10, i);
+
+        expect(v).toBeGreaterThanOrEqual(0);
+        expect(v).toBeLessThanOrEqual(1);
+
+        values.push(v);
     }
 
     values.sort();

package/src/core/model/node-graph/node/Port.spec.js

@@ -40,5 +40,14 @@ test("equality works as intended", () => {
     b.id = a.id;
 
     expect(b.equals(a)).toEqual(true);
-    
+
+});
+
+test("toString on newly crated instance produces a valid string", () => {
+    const port = new Port();
+
+    const s = port.toString();
+
+    expect(typeof s).toBe('string');
+    expect(s.trim().length).toBeGreaterThan(0); // non-empty
 });

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.js

@@ -1,7 +1,6 @@
 import { assert } from "../../../assert.js";
 import { BitSet } from "../../../binary/BitSet.js";
 import { HashMap } from "../../../collection/HashMap.js";
-import { returnZero } from "../../../function/Functions.js";
 import { max2 } from "../../../math/max2.js";
 import DataType from "../../../parser/simple/DataType.js";
 
@@ -95,15 +94,13 @@ class ExpressionNode {
 
 /**
  *
- * @param {ExpressionNode} n
- * @return {number}
+ * @param {ReactiveExpression} exp
+ * @returns {number}
  */
-function scoreNode(n) {
-    return n.getScore();
+function scoreByTreeSize(exp){
+    return  exp.computeTreeSize();
 }
 
-const temp_array = [];
-
 /**
  * Evaluate given state against multiple predicates, order of evaluation is controlled by scoring function, highest score nodes are evaluated first
  */
@@ -112,7 +109,7 @@ export class MultiPredicateEvaluator {
      *
      * @param {function(ReactiveExpression):number} scoringFunction
      */
-    constructor(scoringFunction = returnZero) {
+    constructor(scoringFunction = scoreByTreeSize) {
         /**
          *
          * @type {function(ReactiveExpression): number}

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.spec.js

@@ -9,6 +9,47 @@ import { MultiPredicateEvaluator } from "./MultiPredicateEvaluator.js";
 import { randomFromArray } from "../../../math/random/randomFromArray.js";
 import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
 import { randomIntegerBetween } from "../../../math/random/randomIntegerBetween.js";
+import { ReactiveEquals } from "../model/comparative/ReactiveEquals.js";
+
+test('constructor does not throw', () => {
+    expect(() => new MultiPredicateEvaluator()).not.toThrow();
+});
+
+test('build empty', () => {
+    const processor = new MultiPredicateEvaluator();
+
+    expect(() => processor.build([])).not.toThrow();
+});
+
+test('match against empty list of predicates', () => {
+
+    const processor = new MultiPredicateEvaluator();
+    processor.build([]);
+
+    processor.initialize({});
+
+    expect(processor.next()).toBeUndefined();
+});
+
+test('match against one predicate', () => {
+
+    const processor = new MultiPredicateEvaluator();
+
+    const predicate = ReactiveEquals.from(new ReactiveReference('a'), ReactiveLiteralNumber.from(7));
+
+    processor.build([predicate]);
+
+    processor.initialize({ a: 1 });
+
+    expect(processor.next()).toBeUndefined();
+
+    processor.finalize();
+    processor.initialize({ a: 7 });
+
+    expect(processor.next()).toBe(predicate);
+    expect(processor.next()).toBeUndefined();
+
+});
 
 test.skip('performance', () => {
     const random = seededRandom(12319);

package/src/core/model/reactive/trigger/BlackboardTrigger.js

@@ -56,6 +56,11 @@ export class BlackboardTrigger {
 
         if (this.isLinked) {
             //already linked
+
+            if (this.blackboard !== blackboard) {
+                throw new Error(`Already linked to another blackboard`);
+            }
+
             return;
         }
 

package/src/core/model/reactive/trigger/BlackboardTrigger.spec.js

@@ -0,0 +1,24 @@
+import { BlackboardTrigger } from "./BlackboardTrigger.js";
+import { Blackboard } from "../../../../engine/intelligence/blackboard/Blackboard.js";
+
+test("constructor does not throw", () => {
+    expect(() => new BlackboardTrigger()).not.toThrow();
+});
+
+test("numeric equality", () => {
+
+    const trigger = new BlackboardTrigger();
+    trigger.code = "a == 7";
+
+    const bb = Blackboard.fromJSON({
+        a: 7
+    });
+
+    trigger.link(bb);
+
+    expect(trigger.getExpression().getValue()).toBe(true);
+
+    bb.acquireNumber("a").set(1);
+
+    expect(trigger.getExpression().getValue()).toBe(false);
+});

package/src/core/parser/simple/readBooleanToken.js

@@ -0,0 +1,38 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readBooleanToken(text, cursor, length) {
+    const firstChar = text.charAt(cursor);
+
+    let value;
+    let end = cursor;
+
+    if (firstChar === 't' && length - cursor >= 4) {
+        if (text.substring(cursor + 1, cursor + 4) === 'rue') {
+            value = true;
+            end = cursor + 4;
+        } else {
+            throw new ParserError(cursor, `expected 'true', instead got '${text.substring(cursor, cursor + 4)}'`, text);
+        }
+    } else if (firstChar === 'f' && length - cursor >= 5) {
+        if (text.substring(cursor + 1, cursor + 5) === 'alse') {
+            value = false;
+            end = cursor + 5;
+        } else {
+            throw new ParserError(cursor, `expected 'false', instead got '${text.substring(cursor, cursor + 5)}'`, text);
+        }
+    } else {
+        throw new ParserError(cursor, `expected 't' or 'f', instead got '${firstChar}'`, text);
+    }
+
+    return new Token(value, cursor, end, TokenType.LiteralBoolean, DataType.Boolean);
+}

package/src/core/parser/simple/readHexToken.js

@@ -0,0 +1,95 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readHexToken(text, cursor, length) {
+    const c0 = text.charAt(cursor);
+    const c1 = text.charAt(cursor + 1);
+
+    if (c0 !== '0' || !(c1 === 'x' || c1 === 'X')) {
+        throw new ParserError(cursor, 'Expected hex prefix 0x', text);
+    }
+
+    let i = cursor + 2;
+    let value = 0;
+
+    main_loop: for (; i < length;) {
+        const char = text.charAt(i);
+        let digit;
+        switch (char) {
+            case '0':
+                digit = 0;
+                break;
+            case '1':
+                digit = 1;
+                break;
+            case '2':
+                digit = 2;
+                break;
+            case '3':
+                digit = 3;
+                break;
+            case '4':
+                digit = 4;
+                break;
+            case '5':
+                digit = 5;
+                break;
+            case '6':
+                digit = 6;
+                break;
+            case '7':
+                digit = 7;
+                break;
+            case '8':
+                digit = 8;
+                break;
+            case '9':
+                digit = 9;
+                break;
+            case 'a':
+            case 'A':
+                digit = 10;
+                break;
+            case 'b':
+            case 'B':
+                digit = 11;
+                break;
+            case 'c':
+            case 'C':
+                digit = 12;
+                break;
+            case 'd':
+            case 'D':
+                digit = 13;
+                break;
+            case 'e':
+            case 'E':
+                digit = 14;
+                break;
+            case 'f':
+            case 'F':
+                digit = 15;
+                break;
+            default:
+                if (i === cursor) {
+                    //first character is not a digit
+                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] but got '${char}' instead`, text);
+                }
+                //not a digit
+                break main_loop;
+        }
+        i++;
+        value = value * 16 + digit;
+    }
+
+
+    return new Token(value, cursor, i, null, DataType.Number);
+}

package/src/core/parser/simple/readHexToken.spec.js

@@ -0,0 +1,21 @@
+import { readHexToken } from "./readHexToken.js";
+
+test("0x7", () => {
+    const token = readHexToken("0x7", 0, 3);
+    expect(token.value).toBe(7);
+});
+
+test("0xFF", () => {
+    const token = readHexToken("0xFF", 0, 4);
+    expect(token.value).toBe(0xFF);
+});
+
+test("0x1234567890", () => {
+    const token = readHexToken("0x1234567890", 0, 12);
+    expect(token.value).toBe(0x1234567890);
+});
+
+test("0xABCDEF", () => {
+    const token = readHexToken("0xABCDEF", 0, 8);
+    expect(token.value).toBe(0xABCDEF);
+});

package/src/core/parser/simple/readIdentifierToken.js

@@ -0,0 +1,43 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import TokenType from "./TokenType.js";
+import DataType from "./DataType.js";
+
+const RX_IDENTIFIER_CHAR = /^[a-zA-Z0-9_]/;
+/**
+ * @readonly
+ * @type {RegExp}
+ */
+export const RX_IDENTIFIER_FIRST_CHAR = /^[a-zA-Z_]/;
+
+/**
+ * Read C99 style IDENTIFIER token
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readIdentifierToken(text, cursor, length) {
+    let i = cursor;
+
+
+    const firstChar = text.charAt(i);
+
+    if (!RX_IDENTIFIER_FIRST_CHAR.test(firstChar)) {
+        throw new ParserError(i, `Expected first character to match /${RX_IDENTIFIER_FIRST_CHAR.toString()}/, instead got '${firstChar}'`, text);
+    }
+
+    i++;
+
+    for (; i < length; i++) {
+        const char = text.charAt(i);
+
+        if (!RX_IDENTIFIER_CHAR.test(char)) {
+            break;
+        }
+    }
+
+    const value = text.substring(cursor, i);
+
+    return new Token(value, cursor, i, TokenType.Identifier, DataType.String);
+}

package/src/core/parser/simple/readIdentifierToken.spec.js

@@ -0,0 +1,32 @@
+import { readIdentifierToken } from "./readIdentifierToken.js";
+
+test('parse identifier token starting with a number', () => {
+    expect(() => readIdentifierToken('0', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('1', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('2', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('3', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('4', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('5', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('6', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('7', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('8', 0, 1)).toThrow();
+    expect(() => readIdentifierToken('9', 0, 1)).toThrow();
+
+
+    expect(() => readIdentifierToken('9a', 0, 2)).toThrow();
+});
+
+test('parse identifier token with length 1', () => {
+    expect(readIdentifierToken('a', 0, 1).value).toBe('a');
+    expect(readIdentifierToken('A', 0, 1).value).toBe('A');
+    expect(readIdentifierToken('z', 0, 1).value).toBe('z');
+    expect(readIdentifierToken('Z', 0, 1).value).toBe('Z');
+    expect(readIdentifierToken('_', 0, 1).value).toBe('_');
+});
+
+test('parse identifier valid tokens', () => {
+    expect(readIdentifierToken('aa', 0, 2).value).toBe('aa');
+    expect(readIdentifierToken('a1', 0, 2).value).toBe('a1');
+    expect(readIdentifierToken('z ', 0, 2).value).toBe('z');
+    expect(readIdentifierToken('___ ', 0, 4).value).toBe('___');
+});