@woosh/meep-engine 2.44.5 → 2.44.7

package/core/model/node-graph/Connection.d.ts

@@ -5,4 +5,8 @@ export class Connection {
 
     readonly source: NodeInstancePortReference
     readonly target: NodeInstancePortReference
+
+    setSource(endpoint: NodeInstancePortReference): void
+
+    setTarget(endpoint: NodeInstancePortReference): void
 }

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/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() {
@@ -83,6 +84,8 @@ export class NodeGraph {
      * @returns {NodeInstance|undefined}
      */
     getNode(id) {
+        assert.isNonNegativeInteger(id, 'id');
+
         const nodes = this.nodes;
         const n = nodes.length;
 
@@ -98,6 +101,21 @@ export class NodeGraph {
         return undefined;
     }
 
+    /**
+     * Same as getNode but throw exception when node doesn't exist
+     * @param {number} id
+     * @returns {NodeInstance}
+     */
+    getNodeSafe(id) {
+        const result = this.getNode(id);
+
+        if (result === undefined) {
+            throw new Error(`Node ${id} not found`);
+        }
+
+        return result;
+    }
+
     /**
      *
      * @param {number} id
@@ -209,6 +227,52 @@ export class NodeGraph {
         return true;
     }
 
+    /**
+     * 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
+     * @param {number} targetNode
+     * @param {string} targetPort
+     * @returns {number} connection ID
+     */
+    createConnectionByPortName(
+        sourceNode, sourcePort,
+        targetNode, targetPort
+    ) {
+        const source_node_instance = this.getNodeSafe(sourceNode);
+        const target_node_instance = this.getNodeSafe(targetNode);
+
+        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`);
+        }
+
+        if (target_port_object === undefined) {
+            throw new Error(`Target port '${targetPort}' not found`);
+        }
+
+        return this.createConnection(
+            sourceNode, source_port_object.id,
+            targetNode, target_port_object.id,
+        );
+    }
+
     /**
      *
      * @param {number} sourceNode

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

@@ -175,6 +175,8 @@ export class NodeInstance {
      * @returns {NodeInstancePortReference|undefined}
      */
     getEndpoint(port) {
+        assert.isNonNegativeInteger(port, 'port');
+
         const endpoints = this.endpoints;
 
         for (const endpoint of endpoints) {
@@ -203,6 +205,10 @@ export class NodeInstance {
             && isArrayEqual(this.parameters, other.parameters)
             ;
     }
+
+    toString() {
+        return `NodeInstance{ id = ${this.id}, description = ${this.description.id} }`
+    }
 }
 
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.44.5",
+  "version": "2.44.7",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",