@woosh/meep-engine 2.49.6 → 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.6",
+  "version": "2.49.7",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -11,6 +11,8 @@ export declare class LoadingCache<K, V> {
         retryFailed?: boolean
     })
 
+    refresh(key: K): Promise<V>
+
     invalidate(key: K): void
 
     clear(): void

package/src/core/cache/LoadingCache.js

@@ -18,6 +18,10 @@ class Record {
     }
 }
 
+function current_time_in_seconds() {
+    return performance.now() * 1e-3;
+}
+
 const DEFAULT_TIME_TO_LIVE = 10;
 
 /**
@@ -98,13 +102,52 @@ 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();
 
         /**
          *
@@ -118,23 +161,7 @@ export class LoadingCache {
         ) {
 
             // record needs to be loaded
-
-            let promise;
-
-            try {
-                promise = this.#load(key);
-            }catch (e){
-                promise = Promise.reject(e);
-            }
-
-            record = new Record(promise, currentTime);
-
-            this.#internal.put(key, record);
-
-            promise.catch(() => {
-                // mark as failure
-                record.failed = true;
-            });
+            record = this.#load_value(key, currentTime);
 
         }
 

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('___');
+});

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

@@ -0,0 +1,96 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+import ParserError from "./ParserError.js";
+import { readBooleanToken } from "./readBooleanToken.js";
+import { readStringToken } from "./readStringToken.js";
+import { readNumberToken } from "./readNumberToken.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @return {Token}
+ */
+function readArrayLiteral(text, cursor, length) {
+    let i = cursor;
+
+    const firstChar = text.charAt(i);
+    if (firstChar !== '[') {
+        throw new ParserError(cursor, `expected array start: '[', got '${firstChar}' instead`, text);
+    }
+
+    i++;
+
+    const values = [];
+    while (i < length) {
+        i = skipWhitespace(text, i, length);
+
+        const token = readLiteralToken(text, i, length);
+
+        i = token.end;
+
+        values.push(token);
+
+        //try find separator
+        i = skipWhitespace(text, i, length);
+        if (i < length) {
+            const char = text.charAt(i);
+            if (char === ',') {
+                //separator
+                i++;
+            } else if (char === ']') {
+                //end of sequence
+                i++;
+                break;
+            } else {
+                //unexpected input
+                throw new ParserError(i, `Unexpected input '${char}', expected either separator ',' or end of sequence ']'`, text);
+            }
+        } else {
+            throw new ParserError(i, `Unterminated array literal`, text);
+        }
+    }
+
+    return new Token(values, cursor, i, 'array', DataType.Array);
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+function readLiteralToken(text, cursor, length) {
+    const firstChar = text.charAt(cursor);
+
+    switch (firstChar) {
+        case 't':
+        case 'f':
+            return readBooleanToken(text, cursor, length);
+        case '\"':
+        case "\'":
+            return readStringToken(text, cursor, length);
+        case '-':
+        case '+':
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+            return readNumberToken(text, cursor, length);
+        case '[':
+            return readArrayLiteral(text, cursor, length);
+        default:
+            throw new ParserError(cursor, "Expected literal start, but found '" + firstChar + "'", text);
+    }
+}
+
+export { readLiteralToken };

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

@@ -0,0 +1,73 @@
+import { skipWhitespace } from "./skipWhitespace.js";
+import { readHexToken } from "./readHexToken.js";
+import { readUnsignedIntegerToken } from "./readUnsignedIntegerToken.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 readNumberToken(text, cursor, length) {
+    let i = cursor;
+
+    //read optional sign
+    function readSign(text) {
+        let sign = 1;
+        const firstChar = text.charAt(i);
+        if (firstChar === '-') {
+            sign = -1;
+        } else if (firstChar === '+') {
+            sign = 1;
+        } else {
+            return 1;
+        }
+
+        i = skipWhitespace(text, i + 1, length);
+
+        return sign;
+    }
+
+    const sign = readSign(text);
+
+    let value;
+
+    if (text.charAt(i) === '0' && (text.charAt(i + 1) === 'x' || text.charAt(i + 1) === 'X')) {
+        // hex number
+        const token = readHexToken(text, i, length);
+
+        i = token.end;
+
+        value = token.value;
+
+    } else {
+
+        const wholePart = readUnsignedIntegerToken(text, i, length);
+
+        i = wholePart.end;
+
+        value = wholePart.value;
+
+        if (i < length) {
+            const dot = text.charAt(i);
+            if (dot === '.') {
+                i++;
+                const fraction = readUnsignedIntegerToken(text, i, length);
+
+                const digits = (fraction.end - fraction.start);
+
+                value += fraction.value / Math.pow(10, digits);
+
+                i = fraction.end;
+            }
+        }
+    }
+
+    value *= sign;
+
+    return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
+}