@woosh/meep-engine 2.44.7 → 2.45.1

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/collection/HashMap.d.ts

@@ -29,7 +29,7 @@ export class HashMap<K, V> implements Iterable<[V, K]> {
 
     forEach(callback: (value: V, key: K, map: this) => any, thisArg?: any): void
 
-    [Symbol.iterator](): IterableIterator<[V, K]>
+    [Symbol.iterator](): IterableIterator<[K, V]>
 
     values(): IterableIterator<V>
 

package/core/collection/HashMap.js

@@ -40,6 +40,7 @@ const DEFAULT_LOAD_FACTOR = 0.75;
 
 /**
  * Implements part of {@link Map} interface
+ * @copyright Alex Goldring (c) 2023
  * @template K,V
  * @extends Map<K,V>
  */
@@ -519,7 +520,7 @@ export class HashMap {
                  */
                 const entry = bucket[i];
 
-                yield  [entry.value, entry.key];
+                yield  [entry.key, entry.value];
             }
         }
 

package/core/localization/LanguageMetadata.js

@@ -0,0 +1,48 @@
+import { assert } from "../assert.js";
+
+/**
+ * Represents information about a language
+ */
+export class LanguageMetadata {
+    /**
+     * Measured in characters per second
+     * @type {number}
+     */
+    reading_speed = 10
+
+    /**
+     * Ordered list of fallback languages, if no value is found for a key in this language, other languages will be attempted in order
+     * Identified by localization key
+     * @see {@link #locale}
+     * @type {string[]}
+     */
+    fallback_languages = []
+
+    /**
+     * Localization key,
+     * @see ISO 639
+     * @type {string}
+     */
+    locale = "";
+
+    fromJSON({
+                 reading_speed = 10,
+                 fallback_languages = []
+             }) {
+
+        assert.isNumber(reading_speed, 'reading_speed');
+        assert.greaterThan(reading_speed, 0, 'reading_speed');
+
+        this.reading_speed = reading_speed;
+
+        this.fallback_languages = fallback_languages;
+    }
+
+    static fromJSON(j) {
+        const r = new LanguageMetadata();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+}

package/core/localization/LocaleDataset.js

@@ -0,0 +1,37 @@
+//
+
+import { assert } from "../assert.js";
+
+/**
+ * Represents data for a single localization
+ */
+export class LocaleDataset {
+    /**
+     * Localized strings, identified by localization key
+     * @type {Object<string>}
+     * @private
+     */
+    __strings = {}
+
+    /**
+     *
+     * Does a given key exist?
+     * @param {string} key
+     * @return {boolean}
+     */
+    hasString(key) {
+        assert.isString(key, 'key');
+
+        return this.__strings[key] !== undefined;
+    }
+
+    /**
+     *
+     * @param {string} key
+     * @returns {string|undefined}
+     */
+    getString(key) {
+        return this.__strings[key];
+    }
+
+}

package/core/localization/Localization.js

@@ -0,0 +1,253 @@
+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 = Object.freeze(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;
+    }
+
+    /**
+     * Request locale switch
+     * Assumes a specific folder structure, each different locale is stored with its locale code as name, and there's also "languages.json" file expected to be in the folder
+     * @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');
+        }
+
+        let _path = path.trim();
+
+        while (_path.endsWith('/') || _path.endsWith('\\')) {
+            // remove trailing slash if present
+            _path.slice(0, _path.length - 1);
+        }
+
+        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 {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);
+    }
+
+    /**
+     * Get a localized string by a key
+     * @param {string} key
+     * @param {object} [seed]
+     *
+     * @returns {string}
+     */
+    getString(key, seed = EMPTY_SEED) {
+        assert.isString(key, 'id');
+
+        const value = this.json[key];
+
+        if (value === undefined) {
+
+            if (this.debug) {
+                this.__debugMissingKey(key, seed)
+            }
+
+            //no value, provide substitute
+            return `@${key}`;
+
+        }
+
+        //value needs to be seeded
+        return seedVariablesIntoTemplateString(value, seed);
+    }
+
+    /**
+     * Does a given key exist?
+     * @param {string} key
+     * @return {boolean}
+     */
+    hasString(key) {
+        return this.json[key] !== undefined;
+    }
+}

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/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/core/process/task/Task.js

@@ -5,7 +5,7 @@
 
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
-import { noop, returnZero } from "../../function/Functions.js";
+import { noop } from "../../function/Functions.js";
 import ObservedInteger from "../../model/ObservedInteger.js";
 import { TaskSignal } from "./TaskSignal.js";
 import TaskState from "./TaskState.js";
@@ -27,14 +27,14 @@ class Task {
             name,
             initializer = noop,
             cycleFunction,
-            computeProgress = returnZero,
+            computeProgress,
             dependencies = [],
             estimatedDuration = 1
         }
     ) {
 
-        assert.typeOf(cycleFunction, "function", 'cycleFunction');
-        assert.typeOf(estimatedDuration, 'number', 'estimatedDuration');
+        assert.isFunction(cycleFunction, 'cycleFunction');
+        assert.isNumber(estimatedDuration, 'estimatedDuration');
 
 
         this.dependencies = dependencies;
@@ -59,7 +59,12 @@ class Task {
          */
         this.initialize = initializer;
 
-        this.computeProgress = computeProgress;
+        if (computeProgress !== undefined) {
+
+            // override progress function
+            this.computeProgress = computeProgress;
+
+        }
 
         this.on = {
             started: new Signal(),
@@ -87,6 +92,18 @@ class Task {
         this.__executedCycleCount = 0;
     }
 
+    computeProgress() {
+
+        const cycles = this.__executedCycleCount;
+
+        if (cycles === 0) {
+            return 0;
+        }
+
+        // inverse logarithmic progression, never reaches 1
+        return 1 - (1 / cycles);
+    }
+
     /**
      * Time in milliseconds that the task has been executing for, suspended time does not count
      * @returns {number}

package/core/process/task/util/iteratorTask.js

@@ -0,0 +1,29 @@
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {string} name
+ * @param {Iterator} iterator
+ * @param {TaskSignal.Continue|TaskSignal.Yield} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
+ * @returns {Task}
+ */
+export function iteratorTask(name, iterator, cycle_signal = TaskSignal.Continue) {
+    assert.defined(iterator, 'iterator');
+    assert.notNull(iterator, 'iterator');
+    assert.isFunction(iterator.next, 'iterator.next');
+
+    return new Task({
+        name,
+        cycleFunction() {
+            const next = iterator.next();
+
+            if (next.done) {
+                return TaskSignal.EndSuccess
+            } else {
+                return cycle_signal;
+            }
+        }
+    })
+}

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/foliage/ViewState.js

@@ -1,6 +1,8 @@
 import { BitSet } from "../../../core/binary/BitSet.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
-import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import {
+    queryBinaryNode_FrustumIntersections_Data
+} from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
@@ -30,6 +32,10 @@ export class ViewState {
          * @type {InstancedMeshGroup}
          */
         this.instances = new InstancedMeshGroup();
+        
+        // make shrinking unlikely to prevent thrashing
+        this.instances.shrinkFactor = 0.4;
+        this.instances.shrinkConstant = 1024;
 
         /**
          *

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