@woosh/meep-engine 2.46.18 → 2.46.20

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.46.18",
+  "version": "2.46.20",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "scripts": {

package/src/core/localization/LocaleDataset.js

@@ -7,11 +7,11 @@ import { assert } from "../assert.js";
  */
 export class LocaleDataset {
     /**
-     * Localized strings, identified by localization key
-     * @type {Object<string>}
+     * Localized objects, identified by localization key
+     * @type {Object<Object|string>}
      * @private
      */
-    __strings = {}
+    #map = {}
 
     /**
      *
@@ -19,19 +19,19 @@ export class LocaleDataset {
      * @param {string} key
      * @return {boolean}
      */
-    hasString(key) {
+    hasKey(key) {
         assert.isString(key, 'key');
 
-        return this.__strings[key] !== undefined;
+        return this.#map[key] !== undefined;
     }
 
     /**
      *
      * @param {string} key
-     * @returns {string|undefined}
+     * @returns {string|Object|undefined}
      */
-    getString(key) {
-        return this.__strings[key];
+    get(key) {
+        return this.#map[key];
     }
 
 }

package/src/core/localization/LocalizationEngine.js

@@ -0,0 +1,98 @@
+import { array_get_index_in_range } from "../collection/array/array_get_index_in_range.js";
+import { assert } from "../assert.js";
+
+const resolve_chain = [];
+
+export class LocalizationEngine {
+    /**
+     *
+     * @type {Object<LocaleDataset>}
+     */
+    #locales = {};
+    /**
+     *
+     * @type {Object<LanguageMetadata>}
+     */
+    #languages = {};
+
+
+    /**
+     *
+     * @param {string} key
+     * @param {LocaleDataset} dataset
+     */
+    setLocaleDataset(key, dataset) {
+        assert.isString(key, 'key');
+        assert.defined(dataset, 'dataset');
+
+        this.#locales[key] = dataset;
+    }
+
+    /**
+     *
+     * @param {LanguageMetadata} metadata
+     */
+    addLanguageMetadata(metadata) {
+        assert.defined(metadata, 'metadata');
+
+        this.#languages[metadata.locale] = metadata;
+    }
+
+    /**
+     *
+     * Resolves language and fragment key to a localized value, follows fallback links of known languages when no value found in requested language
+     *
+     * @param {string} language_key Locale key
+     * @param {string} fragment_key Object key
+     * @returns {Object|string|undefined}
+     */
+    resolve(language_key, fragment_key) {
+
+
+        resolve_chain[0] = language_key;
+        let resolve_cursor = 0;
+        let resolve_chain_end = 1;
+
+        while (resolve_cursor < resolve_chain_end) {
+            const lang = resolve_chain[resolve_cursor++];
+
+            const locale = this.#locales[lang];
+
+            if (locale !== undefined && locale[fragment_key] !== undefined) {
+
+                // found a hit
+                return locale[fragment_key];
+
+            } else {
+
+                // see if there's a fallback locale
+                const metadata = this.#languages[lang];
+
+                if (metadata !== undefined) {
+
+                    const fallbacks = metadata.fallback_languages;
+                    const fallback_count = fallbacks.length;
+
+                    for (let i = 0; i < fallback_count; i++) {
+
+                        const fallback = fallbacks[i];
+
+                        if (array_get_index_in_range(resolve_chain, fallback, 0, resolve_chain_end) !== -1) {
+                            // circular dependency, that language was already attempted
+                            continue;
+                        }
+
+                        resolve_chain[resolve_chain_end++] = fallback;
+
+                    }
+
+                }
+
+            }
+        }
+
+        // chain exhausted, no result found
+        return undefined;
+    }
+
+}

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

@@ -65,6 +65,22 @@ export class NodeDescription {
         this.parameters = [];
     }
 
+    /**
+     * Output ports
+     * @returns {Port[]}
+     */
+    get outPorts() {
+        return this.ports.filter(p => p.direction === PortDirection.Out);
+    }
+
+    /**
+     * Input ports
+     * @returns {Port[]}
+     */
+    get inPorts() {
+        return this.ports.filter(p => p.direction === PortDirection.In);
+    }
+
     /**
      *
      * @param {string} name

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

@@ -80,6 +80,23 @@ export class NodeInstance {
         return count;
     }
 
+    /**
+     * Output port references
+     * @returns {NodeInstancePortReference[]}
+     */
+    get outEndpoints() {
+        return this.endpoints.filter(ref => ref.port.direction === PortDirection.Out);
+    }
+
+    /**
+     * Input port references
+     * @returns {NodeInstancePortReference[]}
+     */
+    get inEndpoints() {
+        return this.endpoints.filter(ref => ref.port.direction === PortDirection.In);
+    }
+
+
     /**
      * Outgoing connections from this node
      * @return {Connection[]}
@@ -151,9 +168,10 @@ export class NodeInstance {
         this.description = node;
 
         //generate endpoints
-        this.endpoints = node.getPorts().map(port => {
+        this.endpoints = node.getPorts().map((port, port_index) => {
             const endpoint = new NodeInstancePortReference();
 
+            endpoint.id = port_index;
             endpoint.port = port;
             endpoint.instance = this;
 

package/src/engine/achievements/AchievementManager.js

@@ -24,6 +24,8 @@ import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import { ClockChannelType } from "../intelligence/behavior/ecs/ClockChannelType.js";
 import { EnginePlugin } from "../plugin/EnginePlugin.js";
 import { makeCubicCurve } from "../../core/math/makeCubicCurve.js";
+import { logger } from "../logging/GlobalLogger.js";
+import { assert } from "../../core/assert.js";
 
 
 const SLOW_CUBIC = makeCubicCurve(0.04, 0.4, 0.9, 0.99);
@@ -134,6 +136,8 @@ export class AchievementManager extends EnginePlugin {
      * @param {String} id
      */
     unlock(id) {
+        assert.isString(id, 'id');
+
         const key = computeAchievementBlackboardFlag(id);
         const value = this.blackboard.acquireBoolean(key, false);
 
@@ -146,6 +150,10 @@ export class AchievementManager extends EnginePlugin {
 
         const achievement = this.getAchievementById(id);
 
+        if (achievement === undefined) {
+            logger.warn(`Attempting to unlock achievement ${id}. Achievement not found`);
+        }
+
         if (achievement !== undefined && this.isGatewayInitialized.getValue()) {
             this.deactivateEntry(achievement);
 

package/src/engine/intelligence/behavior/SelectorBehavior.js

@@ -23,6 +23,19 @@ export class SelectorBehavior extends CompositeBehavior {
         this.__currentBehaviourIndex = -1;
     }
 
+    /**
+     *
+     * @param {Behavior[]} children
+     * @returns {SelectorBehavior}
+     */
+    static from(children) {
+        const r = new SelectorBehavior();
+
+        children.forEach(this.addChild, this);
+
+        return r;
+    }
+
     tick(timeDelta) {
         if (this.__children.length < 1) {
             // no options, nothing chosen