@woosh/meep-engine 2.46.5 → 2.46.7

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

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

@@ -34,8 +34,36 @@ export class NodeGraph {
          * @private
          */
         this.__idpConnections = new IdPool();
+
+        /**
+         * @readonly
+         */
+        this.on = {
+            /**
+             * @type {Signal<NodeInstance,number>}
+             */
+            nodeAdded: this.nodes.on.added,
+
+            /**
+             * @type {Signal<NodeInstance,number>}
+             */
+            nodeRemoved: this.nodes.on.removed,
+
+            /**
+             * @type {Signal<Connection,number>}
+             */
+            connectionAdded: this.connections.on.added,
+
+            /**
+             * @type {Signal<Connection,number>}
+             */
+            connectionRemoved: this.connections.on.removed
+        };
     }
 
+    /**
+     * Clear out all data from the graph
+     */
     reset() {
         this.nodes.reset();
         this.connections.reset();

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

@@ -0,0 +1,82 @@
+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);
+}
+
+/**
+ * Clone portion of a graph as a new graph, retaining connections amongst those nodes
+ * @param {NodeGraph} graph
+ * @param {NodeInstance[]} nodes
+ */
+export function graph_clone_by_node_subset({ graph, nodes }) {
+
+    assert.defined(graph, 'graph');
+    assert.notNull(graph, 'graph');
+
+    assert.defined(nodes, 'nodes');
+    assert.notNull(nodes, 'nodes');
+    assert.isArray(nodes, 'nodes');
+
+    const result = new NodeGraph();
+
+    const cloned_nodes = {};
+
+    nodes.forEach(n => {
+        const id = result.createNode(n.description);
+
+        cloned_nodes[n.id] = id;
+    });
+
+    collectConnectionsAmongst({ graph, nodes })
+        .forEach(connection => {
+
+            const source_node_id = cloned_nodes[connection.source.instance.id];
+            const source_endpoint = result.getNode(source_node_id).getEndpoint(connection.source.port.id);
+
+            const target_node_id = cloned_nodes[connection.target.instance.id];
+            const target_endpoint = result.getNode(target_node_id).getEndpoint(connection.target.port.id);
+
+            result.createConnection(
+                source_node_id, source_endpoint.id,
+                target_node_id, target_endpoint.id
+            );
+
+        });
+
+    return result;
+
+}