@woosh/meep-engine 2.44.6 → 2.44.8

package/core/cache/Cache.js

@@ -395,7 +395,7 @@ export class Cache {
     }
 
     /**
-     *
+     * Please note that the key will be stored inside the cache, so it must be treated as immutable
      * @param {Key} key
      * @param {function(Key):Value} compute
      * @param {*} [compute_context]

package/core/localization/LanguageMetadata.js

@@ -0,0 +1,28 @@
+import { assert } from "../assert.js";
+
+/**
+ *
+ */
+export class LanguageMetadata {
+    /**
+     * Measured in characters per second
+     * @type {number}
+     */
+    reading_speed = 10
+
+    fromJSON({ reading_speed = 10 }) {
+
+        assert.isNumber(reading_speed, 'reading_speed');
+        assert.greaterThan(reading_speed, 0, 'reading_speed');
+
+        this.reading_speed = reading_speed;
+    }
+
+    static fromJSON(j) {
+        const r = new LanguageMetadata();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+}

package/core/localization/Localization.js

@@ -0,0 +1,244 @@
+import levenshtein from "fast-levenshtein";
+import { parseTooltipString } from "../../view/tooltip/gml/parser/parseTooltipString.js";
+import { assert } from "../assert.js";
+import ObservedString from "../model/ObservedString.js";
+import { seedVariablesIntoTemplateString } from "../parser/seedVariablesIntoTemplateString.js";
+import { STRING_TEMPLATE_VARIABLE_REGEX } from "../parser/STRING_TEMPLATE_VARIABLE_REGEX.js";
+import { Cache } from "../cache/Cache.js";
+import { computeStringHash } from "../primitives/strings/computeStringHash.js";
+import { computeHashArray } from "../collection/array/computeHashArray.js";
+import { LanguageMetadata } from "./LanguageMetadata.js";
+
+/**
+ * Validation utility method
+ * @param {string} template
+ * @return {string}
+ */
+function validationMockSeed(template) {
+
+    const result = template.replace(STRING_TEMPLATE_VARIABLE_REGEX, function (match, varName) {
+        return "0";
+    });
+
+    return result;
+}
+
+const EMPTY_SEED = Object.freeze({});
+
+const DEFAULT_LANGUAGE_METADATA = new LanguageMetadata();
+
+export class Localization {
+    constructor() {
+        /**
+         *
+         * @type {AssetManager|null}
+         */
+        this.assetManager = null;
+
+        this.json = {};
+
+        /**
+         * @protected
+         * @type {LanguageMetadata}
+         */
+        this.language_metadata = DEFAULT_LANGUAGE_METADATA;
+
+        /**
+         *
+         * @type {ObservedString}
+         */
+        this.locale = new ObservedString('');
+
+        /**
+         * In debug mode error messages are a lot more verbose and helpful
+         * @type {boolean}
+         */
+        this.debug = true;
+
+        /**
+         * @type {Cache<string[], string>}
+         * @private
+         */
+        this.__failure_cache = new Cache({
+            maxWeight: 1024,
+            keyHashFunction: (key) => computeHashArray(key, computeStringHash)
+        });
+    }
+
+    /**
+     * Measured in characters per second
+     * @deprecated use 'language_metadata' directly instead
+     * @return {number}
+     */
+    get reading_speed() {
+        return this.language_metadata.reading_speed;
+    }
+
+    /**
+     * Time required to read a piece of text, in seconds
+     * @param {string} text
+     * @returns {number} time in seconds
+     */
+    estimateReadingTime(text) {
+        assert.isString(text, 'text');
+
+        return text.length / this.reading_speed;
+    }
+
+    /**
+     *
+     * @param {AssetManager} am
+     */
+    setAssetManager(am) {
+        this.assetManager = am;
+    }
+
+    /**
+     * @returns {boolean}
+     * @param {function(key:string, error:*, original: string)} errorConsumer
+     */
+    validate(errorConsumer) {
+        let result = true;
+
+        for (let key in this.json) {
+            const value = this.json[key];
+
+            const seededValue = validationMockSeed(value);
+
+            try {
+                parseTooltipString(seededValue);
+            } catch (e) {
+                result = false;
+                errorConsumer(key, e, value);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {string} locale
+     * @param {string} path where to look for localization data
+     * @returns {Promise}
+     */
+    loadLocale(locale, path = 'data/database/text') {
+        assert.isString(locale, 'locale');
+        assert.isString(path, 'path');
+
+        const am = this.assetManager;
+
+        if (am === null) {
+            throw new Error('AssetManager is not set');
+        }
+
+        const pLoadData = am.promise(`${path}/${locale}.json`, "json")
+            .then(asset => {
+                const json = asset.create();
+
+                this.json = json;
+
+                this.locale.set(locale);
+            }, reason => {
+
+                console.error(`Failed to load locale data for locale '${locale}' : ${reason}`);
+
+                // reset data
+                this.json = {};
+
+            });
+
+        const pLoadMetadata = am.promise(`${path}/languages.json`, "json")
+            .then(asset => {
+                const languages_metadata = asset.create();
+
+                this.language_metadata = LanguageMetadata.fromJSON(languages_metadata[locale]);
+            }, reason => {
+                console.error(`Failed to load language metadata: ${reason}`);
+
+                this.language_metadata = DEFAULT_LANGUAGE_METADATA;
+            });
+
+        return Promise.all([pLoadData, pLoadMetadata]);
+    }
+
+    /**
+     *
+     * @param {String} id
+     * @return {boolean}
+     */
+    hasString(id) {
+        return this.json[id] !== undefined;
+    }
+
+    /**
+     *
+     * @param {number} value
+     */
+    formatIntegerByThousands(value) {
+        const formatter = new Intl.NumberFormat(this.locale.getValue(), { useGrouping: true });
+
+        return formatter.format(value);
+    }
+
+    /**
+     *
+     * @param {string} id
+     * @param {Object} seed
+     * @private
+     */
+    __debugMissingKey(id, seed) {
+        const locale = this.locale.getValue();
+
+        const seed_string = JSON.stringify(seed);
+
+        const message = this.__failure_cache.getOrCompute([locale, id, seed_string], () => {
+
+            //try to find similar keys
+            const similarities = Object.keys(this.json).map(function (key) {
+                const distance = levenshtein.get(key, id);
+                return {
+                    key,
+                    distance
+                };
+            });
+
+            similarities.sort(function (a, b) {
+                return a.distance - b.distance;
+            });
+
+            const suggestions = similarities.slice(0, 3).map(p => p.key);
+
+            return `No localization value for id='${id}', seed=${seed_string}, approximate matches: ${suggestions.join(', ')}`;
+        });
+
+        console.warn(message);
+    }
+
+    /**
+     *
+     * @param {string} id
+     * @param {object} [seed]
+     *
+     * @returns {string}
+     */
+    getString(id, seed = EMPTY_SEED) {
+        assert.isString(id, 'id');
+
+        const value = this.json[id];
+
+        if (value === undefined) {
+
+            if (this.debug) {
+                this.__debugMissingKey(id, seed)
+            }
+
+            //no value, provide substitute
+            return `@${id}`;
+
+        }
+
+        //value needs to be seeded
+        return seedVariablesIntoTemplateString(value, seed);
+    }
+}

package/core/model/node-graph/Connection.js

@@ -127,6 +127,10 @@ export class Connection {
             ^ (target_hash)
             ;
     }
+
+    toString() {
+        return `Connection{ id = ${this.id}, source=${this.source !== null ? this.source.id : 'null'}, target=${this.target !== null ? this.target.id : 'null'} }`
+    }
 }
 
 

package/core/model/node-graph/DataType.js

@@ -16,7 +16,7 @@ export class DataType {
     }
 
     toString() {
-        return `{DataType: id=${this.id}, name='${this.name}' }`;
+        return `DataType{ id=${this.id}, name='${this.name}' }`;
     }
 
     /**

package/core/model/node-graph/NodeGraph.js

@@ -5,6 +5,7 @@ import { Connection } from "./Connection.js";
 import { NodeInstance } from "./node/NodeInstance.js";
 import { array_push_if_unique } from "../../collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../collection/array/array_remove_first.js";
+import { PortDirection } from "./node/PortDirection.js";
 
 export class NodeGraph {
     constructor() {
@@ -227,6 +228,7 @@ export class NodeGraph {
     }
 
     /**
+     * Utility method to help in creation of connections
      * Same as {@link #createConnection}, but ports are identified by their named instead
      * @param {number} sourceNode
      * @param {string} sourcePort
@@ -236,12 +238,26 @@ export class NodeGraph {
      */
     createConnectionByPortName(
         sourceNode, sourcePort,
-        targetNode, targetPort) {
+        targetNode, targetPort
+    ) {
         const source_node_instance = this.getNodeSafe(sourceNode);
         const target_node_instance = this.getNodeSafe(targetNode);
 
-        const source_port_object = source_node_instance.description.getPortByName(sourcePort);
-        const target_port_object = target_node_instance.description.getPortByName(targetPort);
+        const source_ports = source_node_instance.description.getPortsByName(sourcePort).filter(p => p.direction === PortDirection.Out);
+
+        if (source_ports.length > 1) {
+            throw new Error(`Multiple source ports match name '${sourcePort}'`);
+        }
+
+        const source_port_object = source_ports[0];
+
+        const target_ports = target_node_instance.description.getPortsByName(targetPort).filter(p => p.direction === PortDirection.In);
+
+        if (target_ports.length > 1) {
+            throw new Error(`Multiple target ports match name '${targetPort}'`);
+        }
+
+        const target_port_object = target_ports[0];
 
         if (source_port_object === undefined) {
             throw new Error(`Source port '${sourcePort}' not found`);

package/core/model/node-graph/node/NodeDescription.js

@@ -177,20 +177,31 @@ export class NodeDescription {
 
     /**
      *
-     * @param name
-     * @return {Port|undefined}
+     * @param {string} name
+     * @return {Port[]}
      */
-    getPortByName(name) {
+    getPortsByName(name) {
         assert.isString(name, 'name');
 
-        for (const port of this.ports) {
+        /**
+         *
+         * @type {Port[]}
+         */
+        const result = [];
+
+        const ports = this.ports;
+        const port_count = ports.length;
+
+        for (let i = 0; i < port_count; i++) {
+            const port = ports[i];
+
             if (port.name === name) {
-                return port;
+                result.push(port);
             }
+
         }
 
-        //not found
-        return undefined;
+        return result;
     }
 
     /**

package/core/model/node-graph/node/NodeInstance.js

@@ -205,6 +205,10 @@ export class NodeInstance {
             && isArrayEqual(this.parameters, other.parameters)
             ;
     }
+
+    toString() {
+        return `NodeInstance{ id = ${this.id}, description = ${this.description.id} }`
+    }
 }
 
 

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

@@ -57,6 +57,10 @@ export class Port {
             ;
 
     }
+
+    toString() {
+        return `Port{ id=${this.id}, direction=${this.direction}, name=${this.name}, type=${this.dataType} }`;
+    }
 }
 
 /**

package/editor/view/ecs/components/items/ItemContainerController.stories.js

@@ -1,5 +1,5 @@
 import { storiesOf } from "@storybook/html/dist/client/preview";
-import { Localization } from "../../../../../core/Localization.js";
+import { Localization } from "../../../../../core/localization/Localization.js";
 import { ItemContainerController } from "./ItemContainerController.js";
 import ItemContainer from "../../../../../../model/game/ecs/component/item_container/ItemContainer.js";
 import Item from "../../../../../../model/game/ecs/component/Item.js";

package/engine/Engine.js

@@ -23,7 +23,7 @@ import EmptyView from "../view/elements/EmptyView.js";
 import { assert } from "../core/assert.js";
 import { StaticKnowledgeDatabase } from "./knowledge/database/StaticKnowledgeDatabase.js";
 import Ticker from "./simulation/Ticker.js";
-import { Localization } from "../core/Localization.js";
+import { Localization } from "../core/localization/Localization.js";
 import { ModuleRegistry } from "../core/model/ModuleRegistry.js";
 import { BinarySerializationRegistry } from "./ecs/storage/binary/BinarySerializationRegistry.js";
 import { EnginePluginManager } from "./plugin/EnginePluginManager.js";

package/engine/asset/AssetManager.js

@@ -326,6 +326,10 @@ export class AssetManager {
             throw new Error("Path must be string. Path = " + JSON.stringify(path));
         }
 
+        if(typeof type !== "string"){
+            throw new TypeError(`type must be a string, instead was '${typeof type}'`);
+        }
+
         const assetDescription = new AssetDescription(path, type);
 
         const asset = this.assets.get(assetDescription);

package/engine/ecs/speaker/VoiceSystem.js

@@ -373,7 +373,7 @@ export class VoiceSystem extends AbstractContextSystem {
         // localized line may contain reference tags, the user will not see/read those, so we also compile line as pure text for estimating reading time
         const line_pure_text = gml.compileAsText(localized_line);
 
-        const display_time_raw = localiation.computeReadingTime(line_pure_text);
+        const display_time_raw = localiation.estimateReadingTime(line_pure_text);
 
         const display_time = max2(TIMING_MINIMUM_READ_TIME, display_time_raw * line.displayDuration) + TIMING_NOTICE_DELAY;
 

package/engine/graphics/ecs/decal/v2/prototypeDecalSystem.js

@@ -15,7 +15,7 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import '../../../../../../../../css/game.scss';
 import { countTask } from "../../../../../core/process/task/util/countTask.js";
-import Vector2 from "../../../../../core/geom/Vector2.js";
+import Vector2, { v2_distance } from "../../../../../core/geom/Vector2.js";
 import { RotationBehavior } from "../../../../intelligence/behavior/util/RotationBehavior.js";
 import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
@@ -270,14 +270,17 @@ function grid(ecd, offset_x, offset_y, x, y, size_x, size_y, spacing, textures)
 function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
     const uv = new OctahedralUvEncoder();
 
-    const GRID_SIZE = 9;
+    const GRID_SIZE = 16;
 
     const CELL_SIZE = 1;
 
-    const SPACING = CELL_SIZE*1.2;
+    const SPACING = CELL_SIZE * 1.2;
+    // const SPACING = CELL_SIZE * 0.6;
 
     const DEBUG_BOX = makeHelperBoxGeometry();
 
+    const random = seededRandom(7);
+
     for (let i = 0; i < GRID_SIZE; i++) {
         for (let j = 0; j < GRID_SIZE; j++) {
 
@@ -290,7 +293,7 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
             const decal = new Decal();
 
             // decal.uri = decal_urls[1];
-            decal.uri ='moicon/ISO 7010 - Safety Signs (3)/ISO 7010 - Safety Signs/Emergency/400px/E001 – Emergency exit (left hand).png';
+            decal.uri = 'moicon/ISO 7010 - Safety Signs (3)/ISO 7010 - Safety Signs/Emergency/400px/E001 – Emergency exit (left hand).png';
 
             const entity = new EntityBuilder();
 
@@ -303,7 +306,7 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                 0,
             );
             transform.scale.setScalar(CELL_SIZE);
-            transform.rotation._lookRotation(direction[0],direction[2], direction[1] , 0, 1, 0);
+            transform.rotation._lookRotation(direction[0], direction[2], direction[1], 0, 1, 0);
 
             transform.multiplyTransforms(root_transform, transform);
 
@@ -314,9 +317,12 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                 .add(decal)
                 .build(ecd);
 
-            setInterval(()=>{
-                decal.priority = Math.random();
-            },7000);
+            // setInterval(()=>{
+            //     decal.priority = Math.random();
+            // },7000);
+
+            // decal.priority = randomIntegerBetween(random,0,4096);
+            decal.priority = v2_distance(i, j, GRID_SIZE * 0.5, GRID_SIZE * 0.5);
 
 
             // make an arrow helper
@@ -330,7 +336,7 @@ function makeNormalTestGridDecal(ecd, root_transform = new Transform()) {
                     side: DoubleSide
                 }), DrawMode.Triangles))
                 .add(arrow_transform)
-                .build(ecd);
+            .build(ecd);
         }
     }
 }
@@ -448,9 +454,9 @@ async function main(engine) {
     new EntityBuilder()
         .add(SGMesh.fromURL('data/models/snaps/cube_white.gltf'))
         .add(Transform.fromJSON({
-        position:new Vector3(14,1,4.8),
+            position: new Vector3(14, 1, 4.8),
             rotation: t_forward_grid.rotation,
-            scale: new Vector3(25,25,0.1)
+            scale: new Vector3(25, 25, 0.1)
         }))
         .build(ecd);