- delete operation improvements

- undo redo history grouped by dialoge sequence ast

Author: Joseph Star

addons/parley/graph_operations/parley_delete_operation.gd

@@ -3,20 +3,17 @@ class_name ParleyDeleteOperation
 extends ParleyGraphOperation
 
 var selected_connections: Array[ParleyGraphEdge]
-var selected_nodes: Array[ParleyGraphNode]
+var selected_node_ids: Array[String]
 var deleted_node_datas: Array[NodeData]
 var graph_view: ParleyGraphView
 
 func _init(_graph_view: ParleyGraphView, _selected_connections: Array[ParleyGraphEdge], _selected_nodes: Array[ParleyGraphNode]) -> void:
 	graph_view = _graph_view
 	selected_connections = _selected_connections.duplicate()
-	selected_nodes = _selected_nodes.duplicate()
-
+	for node: ParleyGraphNode in _selected_nodes:
+		selected_node_ids.append(node.id)
+	
 func undo() -> void:
-	pass
-	# Re-add deleted nodes
-
-	selected_nodes.clear()
 	var graph_nodes: Dictionary = {}
 	for node_data : NodeData in deleted_node_datas:
 		var deleted_node : ParleyNodeAst = node_data.node_ast
@@ -27,47 +24,43 @@ func undo() -> void:
 
 	for node_data : NodeData in deleted_node_datas:
 		for connection : ParleyGraphEdge in node_data.connections:
-			connection.to_node = graph_view.get_node(NodePath(connection.to_node_name)) as ParleyGraphNode
-			connection.from_node = graph_view.get_node(NodePath(connection.from_node_name)) as ParleyGraphNode
-			if node_data.node_name == connection.to_node_name:
-				selected_nodes.append(connection.to_node)
-				pass
-			elif node_data.node_name == connection.from_node_name:
-				selected_nodes.append(connection.from_node)
-				pass
+			connection.to_node = graph_view.get_node(NodePath(connection.to_node_name))
+			connection.from_node = graph_view.get_node(NodePath(connection.from_node_name))
 			connection.connect_node(graph_view)
 
 	for connection : ParleyGraphEdge in selected_connections:
-		connection.to_node = graph_view.get_node(NodePath(connection.to_node_name)) as ParleyGraphNode
-		connection.from_node = graph_view.get_node(NodePath(connection.from_node_name)) as ParleyGraphNode
+		connection.to_node = graph_view.get_node(NodePath(connection.to_node_name))
+		connection.from_node = graph_view.get_node(NodePath(connection.from_node_name))
 		connection.connect_node(graph_view)
 
 	graph_view.generate()
 
 func do() -> void:
-	for selected_node : ParleyGraphNode in selected_nodes:
-		if graph_view.has_node(NodePath(selected_node.name)):
-			var ast : ParleyNodeAst = graph_view.ast.find_node_by_id(selected_node.id)
-			var connections : Array[ParleyGraphEdge] = get_connections_for_node(graph_view, selected_node)
-			deleted_node_datas.append(NodeData.new(selected_node.name, ast, connections))
+	deleted_node_datas.clear()
+	for selected_node_id : String in selected_node_ids:
+		var ast : ParleyNodeAst = graph_view.ast.find_node_by_id(selected_node_id)
+		if ast != null:
+			var connections : Array[ParleyGraphEdge] = get_connections_for_node(graph_view, selected_node_id)
+			deleted_node_datas.append(NodeData.new(selected_node_id, ast, connections))
 
-	for selected_node : ParleyGraphNode in selected_nodes:
-		if graph_view.has_node(NodePath(selected_node.name)):
-			print("remove node")
-			var ast : ParleyNodeAst = graph_view.ast.find_node_by_id(selected_node.id)
+	for selected_node_id : String in selected_node_ids:
+		var ast : ParleyNodeAst = graph_view.ast.find_node_by_id(selected_node_id)
+		if ast != null:
+			print(selected_node_id)
+			var selected_node : ParleyGraphNode = graph_view.find_node_by_id(selected_node_id)
 			graph_view._on_node_deselected(selected_node)
 			graph_view.remove_child(selected_node)
-			graph_view.ast.remove_node(selected_node.id)
+			graph_view.ast.remove_node(selected_node_id)
 
+	graph_view._on_connections_deselected()
 	for connection : ParleyGraphEdge in selected_connections:
-		print("disconnect connection")
 		connection.disconnect_node(graph_view)
-		
+
 	graph_view.generate()
 
-func get_connections_for_node(graph_edit: GraphEdit, node: GraphNode) -> Array[ParleyGraphEdge]:
+func get_connections_for_node(graph_view: ParleyGraphView, node_id: String) -> Array[ParleyGraphEdge]:
 	var result: Array[ParleyGraphEdge] = []
-	var connections: Array[Dictionary] = graph_edit.get_connection_list()
+	var connections: Array[Dictionary] = graph_view.get_connection_list()
 
 	for conn: Dictionary in connections:
 		var from_name: String = conn.get("from_node")
@@ -77,19 +70,20 @@ func get_connections_for_node(graph_edit: GraphEdit, node: GraphNode) -> Array[P
 		var to_node: ParleyGraphNode = graph_view.get_node(NodePath(to_name)) as ParleyGraphNode
 		var from_node: ParleyGraphNode = graph_view.get_node(NodePath(from_name)) as ParleyGraphNode
 
-		if from_name == node.name or to_name == node.name:
-			result.append(ParleyGraphEdge.new(from_node, from_port, to_node, to_port))
+		if to_node.id == node_id or from_node.id == node_id:
+			var edge_ast: ParleyEdgeAst = graph_view.ast.get_edge_ast(from_node.id, from_port, to_node.id, to_port)
+			result.append(ParleyGraphEdge.new(edge_ast, from_node, from_port, to_node, to_port))
 
 	return result
 
 
 class NodeData:
 	var node_ast: ParleyNodeAst
 	var connections: Array[ParleyGraphEdge]
-	var node_name: String
+	var node_id: String
 
-	func _init(_node_name: String, _node_ast :ParleyNodeAst, _connections: Array[ParleyGraphEdge]) -> void:
-		node_name = _node_name
+	func _init(_node_id: String, _node_ast :ParleyNodeAst, _connections: Array[ParleyGraphEdge]) -> void:
+		node_id = _node_id
 		node_ast = _node_ast
 		connections = _connections
 

addons/parley/main_panel.gd

@@ -55,8 +55,8 @@ var selected_node_ast: ParleyNodeAst: set = _set_selected_node_ast
 signal dialogue_ast_selected(dialogue_ast: ParleyDialogueSequenceAst)
 signal node_selected(node_ast: ParleyNodeAst)
 
-var undoHistory: Array[ParleyGraphOperation] = []
-var redoHistory: Array[ParleyGraphOperation] = []
+var undoHistory: Dictionary = {}
+var redoHistory: Dictionary = {}
 
 #region SETUP
 func _ready() -> void:
@@ -681,20 +681,25 @@ func _delete_selected() -> void:
 		add_undo_operation(deleteConnection)
 
 func add_undo_operation(operation: ParleyGraphOperation) -> void:
-	redoHistory.clear()
-	undoHistory.push_back(operation)
+	if not undoHistory.has(dialogue_ast):
+		undoHistory[dialogue_ast] = [] as Array[ParleyGraphOperation]
+	if not redoHistory.has(dialogue_ast):
+		redoHistory[dialogue_ast] = [] as Array[ParleyGraphOperation]
+	
+	redoHistory[dialogue_ast].clear()
+	undoHistory[dialogue_ast].push_back(operation)
 
 func _undo() -> void:
-	if undoHistory.size() > 0:
+	if undoHistory[dialogue_ast].size() > 0:
 		print("Undo")
-		var operation: ParleyGraphOperation = undoHistory.pop_back()
+		var operation: ParleyGraphOperation = undoHistory[dialogue_ast].pop_back()
 		operation.undo()
-		redoHistory.push_back(operation)
+		redoHistory[dialogue_ast].push_back(operation)
 
 func _redo() -> void:
-	if redoHistory.size() > 0:
+	if redoHistory[dialogue_ast].size() > 0:
 		print("Redo")
-		var operation: ParleyGraphOperation = redoHistory.pop_back()
+		var operation: ParleyGraphOperation = redoHistory[dialogue_ast].pop_back()
 		operation.do()
 		add_undo_operation(operation)
 

addons/parley/models/dialogue_sequence_ast.gd

@@ -706,6 +706,11 @@ func _emit_dialogue_updated() -> void:
 	if is_ready:
 		dialogue_updated.emit(self)
 
+func get_edge_ast(from_node: String, from_slot: int, to_node: String, to_slot: int) -> ParleyEdgeAst:
+	for edge: ParleyEdgeAst in edges:
+		if edge.from_node == from_node && edge.from_slot == from_slot && edge.to_node == to_node && edge.to_slot == to_slot:
+			return edge
+	return null
 
 func _to_string() -> String:
 	return "ParleyDialogueSequenceAst<nodes=%d edges=%d>" % [nodes.size(), edges.size()]

addons/parley/views/parley_graph_edge.gd

@@ -11,12 +11,13 @@ var to_slot: int
 var to_port: int
 var to_node_name: String
 var from_node_name: String
+var edge_ast: ParleyEdgeAst
 
 var previousFromColor: Color
 var previousToColor: Color
 var selected: bool
 
-func _init(_from_node: ParleyGraphNode, _from_port: int, _to_node: ParleyGraphNode, _to_port: int) -> void:
+func _init(_edge_ast: ParleyEdgeAst, _from_node: ParleyGraphNode, _from_port: int, _to_node: ParleyGraphNode, _to_port: int) -> void:
 	from_node = _from_node
 	from_port = _from_port
 	to_node = _to_node
@@ -25,16 +26,18 @@ func _init(_from_node: ParleyGraphNode, _from_port: int, _to_node: ParleyGraphNo
 	to_slot = to_node.get_input_port_slot(to_port)
 	from_node_name = from_node.name
 	to_node_name = to_node.name
+	edge_ast = _edge_ast
 
 func disconnect_node(graph_view: ParleyGraphView) -> void:
 	if not graph_view:
 		return
+	graph_view.ast.remove_edge(from_node.id, from_port, to_node.id, to_port)
 	graph_view.disconnect_node(from_node_name, from_port, to_node_name, to_port)
-	graph_view.ast.remove_edge(from_node_name, from_port, to_node_name, to_port)
 
 func connect_node(graph_view: ParleyGraphView) -> int:
 	if not graph_view:
 		return FAILED
+	graph_view.ast.edges.append(edge_ast)
 	return graph_view.connect_node(from_node_name, from_port, to_node_name, to_port)
 
 func select() -> void:
@@ -57,4 +60,4 @@ func unselect() -> void:
 	to_node.set_slot_color_left(to_slot, previousToColor)
 
 func as_string() -> String:
-	return "%s:%d -> %s:%d" % [from_node, from_port, to_node, to_port]
+	return "%s:%d -> %s:%d" % [from_node_name, from_port, to_node_name, to_port]

addons/parley/views/parley_graph_view.gd

@@ -370,6 +370,11 @@ func _on_node_selected(node: Node) -> void:
 func _on_node_deselected(node: Node) -> void:
 	selectedNodes.erase(node)
 	pass
+func _on_connections_deselected() -> void:
+	while onUnselect.size() > 0:
+		var callable: Callable = onUnselect.pop_front()
+		callable.call()
+
 func _gui_input(event: InputEvent) -> void:
 	if event is InputEventMouseButton:
 		_handle_mouse_select(event as InputEventMouseButton)
@@ -420,19 +425,20 @@ func _handle_mouse_select(mouse_event: InputEventMouseButton) -> void:
 
 				foundAnyConnection = true
 				var connection: ParleyGraphEdge = _find_existing_connection(from_node, from_port, to_node, to_port)
+				var edge_ast: ParleyEdgeAst = ast.get_edge_ast(from_node.id, from_port, to_node.id, to_port)
 				if connection == null:
-					connection = ParleyGraphEdge.new(from_node, from_port, to_node, to_port)
+					connection = ParleyGraphEdge.new(edge_ast, from_node, from_port, to_node, to_port)
 					connection.select()
 					selectedConnections.append(connection as ParleyGraphEdge)
 					onUnselect.append(func() -> void:
 						connection.unselect()
 						selectedConnections.erase(connection)
 					)
-					print("Selected connection:", connection.as_string())
+					print("Selected connection: ", connection.as_string())
 				else:
 					selectedConnections.erase(connection)
 					connection.unselect()
-					print("Unselected existing connection:", connection.as_string())
+					print("Unselected existing connection: ", connection.as_string())
 				break
 
 		if not foundAnyConnection && not mouse_event.is_command_or_control_pressed():