@woosh/meep-engine 2.46.7 → 2.46.10

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.7",
+  "version": "2.46.10",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "scripts": {

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

@@ -106,6 +106,26 @@ export class NodeGraph {
         return this.connections.data.slice();
     }
 
+    /**
+     *
+     * @param {NodeInstance} node
+     * @returns {boolean}
+     */
+    hasNode(node) {
+        const existing_node = this.getNode(node.id);
+
+        if (existing_node === undefined) {
+            return false;
+        }
+
+        if (existing_node !== node) {
+            // another node with this ID was found
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      *
      * @param {number} id

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

@@ -29,6 +29,12 @@ function pickNewSetId(things) {
     return r;
 }
 
+/**
+ *
+ * @type {number}
+ */
+let node_id_counter = 0;
+
 export class NodeDescription {
     constructor() {
         /**
@@ -38,10 +44,13 @@ export class NodeDescription {
         this.name = "";
 
         /**
-         *
+         * A unique identifier in the scope of a single registry
+         * If two nodes belong to the same registry - they must have different IDs
+         * By default an auto-incrementing ID is assigned, as this ID is assigned at the time of object construction - it may be subject to race conditions
+         * In case nodes are loaded or constructed in async manner - consider using your own ID assignment scheme
          * @type {number}
          */
-        this.id = 0;
+        this.id = node_id_counter++;
 
         /**
          * @protected

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

@@ -119,6 +119,10 @@ export class NodeInstancePortReference {
             && this.port.equals(other.port)
             ;
     }
+
+    toString() {
+        return `NodeInstancePortReference{ id=${this.id}, instance=${this.instance}, port=${this.port}, connections.length=${this.connections.length} }`;
+    }
 }
 
 /**

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

@@ -38,12 +38,21 @@ export class NodeRegistry {
     /**
      *
      * @param {NodeDescription} node
+     * @returns {boolean} true if node was added, false if node already exists
      */
     addNode(node) {
         assert.defined(node, "node");
         assert.notNull(node, "node");
 
-        if (this.nodes.has(node.id)) {
+        const existing_node = this.nodes.get(node.id);
+
+        if (existing_node !== undefined) {
+
+            if (existing_node !== node) {
+                // node with the same ID exists and is not the same node
+                throw new Error(`A different node with the same ID ${node.id} is already registered. IDs of all nodes in the registry must be unique`);
+            }
+
             // console.warn(`Node with id ${node.id} already exists`);
 
             return false;

package/src/core/model/node-graph/util/graph_clone_by_node_subset.js

@@ -1,41 +1,6 @@
 import { NodeGraph } from "../NodeGraph.js";
 import { assert } from "../../../assert.js";
-
-/**
- *
- * @param {NodeGraph} graph
- * @param {NodeInstance[]} nodes
- * @returns {Connection[]}
- */
-function collectConnectionsAmongst({
-                                       graph,
-                                       nodes
-                                   }) {
-
-    const r = new Set();
-
-    const node_count = nodes.length;
-    for (let i = 0; i < node_count; i++) {
-        const node_0 = nodes[i];
-
-        const connections = node_0.connections.asArray();
-        const connection_count = connections.length;
-
-        for (let j = 0; j < connection_count; j++) {
-            const connection = connections[j];
-
-            for (let k = i + 1; k < node_count; k++) {
-                const node_1 = nodes[k];
-
-                if (connection.isAttachedToNode(node_1.id)) {
-                    r.add(connection);
-                }
-            }
-        }
-    }
-
-    return Array.from(r);
-}
+import { graph_collect_connections_amongst_nodes } from "./graph_collect_connections_amongst_nodes.js";
 
 /**
  * Clone portion of a graph as a new graph, retaining connections amongst those nodes
@@ -53,15 +18,24 @@ export function graph_clone_by_node_subset({ graph, nodes }) {
 
     const result = new NodeGraph();
 
+    /**
+     * Maps from source node IDs to result node IDs
+     * @type {Object<number,number>}
+     */
     const cloned_nodes = {};
 
     nodes.forEach(n => {
+
+        if (!graph.hasNode(n)) {
+            throw new Error(`Referenced node ${n} is not a found in the graph`);
+        }
+
         const id = result.createNode(n.description);
 
         cloned_nodes[n.id] = id;
     });
 
-    collectConnectionsAmongst({ graph, nodes })
+    graph_collect_connections_amongst_nodes({ graph, nodes })
         .forEach(connection => {
 
             const source_node_id = cloned_nodes[connection.source.instance.id];

package/src/core/model/node-graph/util/graph_collect_connections_amongst_nodes.js

@@ -0,0 +1,50 @@
+/**
+ * Given a graph and a set of nodes, get all connections that connect these nodes amongst themselves
+ * @param {NodeGraph} graph
+ * @param {NodeInstance[]} nodes
+ * @returns {Connection[]}
+ */
+export function graph_collect_connections_amongst_nodes({
+                                                            graph,
+                                                            nodes
+                                                        }) {
+
+    const r = new Set();
+
+    const node_count = nodes.length;
+
+    for (let i = 0; i < node_count; i++) {
+        const node_0 = nodes[i];
+
+        const connections = node_0.connections.asArray();
+        const connection_count = connections.length;
+
+        for (let j = 0; j < connection_count; j++) {
+            const connection = connections[j];
+
+            if (connection.source.instance === connection.target.instance) {
+                // Special case. Auto-connection, from node to itself
+                r.add(connection);
+                continue;
+            }
+
+            for (let k = i + 1; k < node_count; k++) {
+                const node_1 = nodes[k];
+
+                if (node_0 === node_1) {
+                    // duplicate node found
+                    continue;
+                }
+
+                if (connection.isAttachedToNode(node_1.id)) {
+                    r.add(connection);
+
+                    // connection can only exist between two ports, so we're done
+                    break;
+                }
+            }
+        }
+    }
+
+    return Array.from(r);
+}