progress.

addons/cutscene_editor/editor/UndoRedoManager.gd

@@ -0,0 +1,246 @@
+@tool
+class_name UndoRedoManager
+extends Object
+
+# Manager for undo/redo operations
+
+# Signals
+signal undo_redo_state_changed()
+
+# Properties
+var undo_stack: Array = []  # Stack of undo operations
+var redo_stack: Array = []  # Stack of redo operations
+var max_history: int = 100  # Maximum number of operations to store
+var is_processing: bool = false  # Flag to prevent recursive processing
+
+# Operation types
+enum OperationType {
+	NODE_ADDED,
+	NODE_REMOVED,
+	NODE_MOVED,
+	NODE_PROPERTY_CHANGED,
+	CONNECTION_CREATED,
+	CONNECTION_REMOVED,
+	GRAPH_CLEARED
+}
+
+# Initialize the undo/redo manager
+func _init() -> void:
+	pass
+
+# Add an operation to the undo stack
+func add_operation(operation: Dictionary) -> void:
+	if is_processing:
+		return
+	
+	# Add to undo stack
+	undo_stack.push_back(operation)
+	
+	# Limit stack size
+	if undo_stack.size() > max_history:
+		undo_stack.pop_front()
+	
+	# Clear redo stack when new operation is added
+	redo_stack.clear()
+	
+	# Emit signal
+	emit_signal("undo_redo_state_changed")
+
+# Perform undo operation
+func undo() -> void:
+	if undo_stack.is_empty():
+		return
+	
+	# Set processing flag to prevent recursive calls
+	is_processing = true
+	
+	# Get last operation
+	var operation = undo_stack.pop_back()
+	
+	# Perform reverse operation
+	_perform_reverse_operation(operation)
+	
+	# Add to redo stack
+	redo_stack.push_back(operation)
+	
+	# Limit redo stack size
+	if redo_stack.size() > max_history:
+		redo_stack.pop_front()
+	
+	# Clear processing flag
+	is_processing = false
+	
+	# Emit signal
+	emit_signal("undo_redo_state_changed")
+
+# Perform redo operation
+func redo() -> void:
+	if redo_stack.is_empty():
+		return
+	
+	# Set processing flag to prevent recursive calls
+	is_processing = true
+	
+	# Get last redo operation
+	var operation = redo_stack.pop_back()
+	
+	# Perform original operation
+	_perform_operation(operation)
+	
+	# Add to undo stack
+	undo_stack.push_back(operation)
+	
+	# Limit undo stack size
+	if undo_stack.size() > max_history:
+		undo_stack.pop_front()
+	
+	# Clear processing flag
+	is_processing = false
+	
+	# Emit signal
+	emit_signal("undo_redo_state_changed")
+
+# Check if undo is possible
+func can_undo() -> bool:
+	return not undo_stack.is_empty()
+
+# Check if redo is possible
+func can_redo() -> bool:
+	return not redo_stack.is_empty()
+
+# Clear all history
+func clear_history() -> void:
+	undo_stack.clear()
+	redo_stack.clear()
+	emit_signal("undo_redo_state_changed")
+
+# Perform an operation
+func _perform_operation(operation: Dictionary) -> void:
+	# This would be implemented in the graph editor
+	pass
+
+# Perform the reverse of an operation
+func _perform_reverse_operation(operation: Dictionary) -> void:
+	match operation["type"]:
+		OperationType.NODE_ADDED:
+			_reverse_node_added(operation)
+		OperationType.NODE_REMOVED:
+			_reverse_node_removed(operation)
+		OperationType.NODE_MOVED:
+			_reverse_node_moved(operation)
+		OperationType.NODE_PROPERTY_CHANGED:
+			_reverse_node_property_changed(operation)
+		OperationType.CONNECTION_CREATED:
+			_reverse_connection_created(operation)
+		OperationType.CONNECTION_REMOVED:
+			_reverse_connection_removed(operation)
+		OperationType.GRAPH_CLEARED:
+			_reverse_graph_cleared(operation)
+
+# Create operation for node added
+func create_node_added_operation(node: BaseGraphNode) -> Dictionary:
+	return {
+		"type": OperationType.NODE_ADDED,
+		"node_name": node.name,
+		"node_type": node.node_type,
+		"position": node.position_offset,
+		"parameters": node.action_parameters.duplicate(true)
+	}
+
+# Reverse node added operation
+func _reverse_node_added(operation: Dictionary) -> void:
+	# This would remove the node in the graph editor
+	pass
+
+# Create operation for node removed
+func create_node_removed_operation(node: BaseGraphNode) -> Dictionary:
+	return {
+		"type": OperationType.NODE_REMOVED,
+		"node_name": node.name,
+		"node_type": node.node_type,
+		"position": node.position_offset,
+		"parameters": node.action_parameters.duplicate(true),
+		"connections": _get_node_connections(node.name)
+	}
+
+# Reverse node removed operation
+func _reverse_node_removed(operation: Dictionary) -> void:
+	# This would add the node back in the graph editor
+	pass
+
+# Create operation for node moved
+func create_node_moved_operation(node_name: String, old_position: Vector2, new_position: Vector2) -> Dictionary:
+	return {
+		"type": OperationType.NODE_MOVED,
+		"node_name": node_name,
+		"old_position": old_position,
+		"new_position": new_position
+	}
+
+# Reverse node moved operation
+func _reverse_node_moved(operation: Dictionary) -> void:
+	# This would move the node back to its old position in the graph editor
+	pass
+
+# Create operation for node property changed
+func create_node_property_changed_operation(node_name: String, property_name: String, old_value, new_value) -> Dictionary:
+	return {
+		"type": OperationType.NODE_PROPERTY_CHANGED,
+		"node_name": node_name,
+		"property_name": property_name,
+		"old_value": old_value,
+		"new_value": new_value
+	}
+
+# Reverse node property changed operation
+func _reverse_node_property_changed(operation: Dictionary) -> void:
+	# This would restore the old property value in the graph editor
+	pass
+
+# Create operation for connection created
+func create_connection_created_operation(from_node: String, from_port: int, to_node: String, to_port: int) -> Dictionary:
+	return {
+		"type": OperationType.CONNECTION_CREATED,
+		"from_node": from_node,
+		"from_port": from_port,
+		"to_node": to_node,
+		"to_port": to_port
+	}
+
+# Reverse connection created operation
+func _reverse_connection_created(operation: Dictionary) -> void:
+	# This would remove the connection in the graph editor
+	pass
+
+# Create operation for connection removed
+func create_connection_removed_operation(from_node: String, from_port: int, to_node: String, to_port: int) -> Dictionary:
+	return {
+		"type": OperationType.CONNECTION_REMOVED,
+		"from_node": from_node,
+		"from_port": from_port,
+		"to_node": to_node,
+		"to_port": to_port
+	}
+
+# Reverse connection removed operation
+func _reverse_connection_removed(operation: Dictionary) -> void:
+	# This would recreate the connection in the graph editor
+	pass
+
+# Create operation for graph cleared
+func create_graph_cleared_operation(nodes: Array, connections: Array) -> Dictionary:
+	return {
+		"type": OperationType.GRAPH_CLEARED,
+		"nodes": nodes.duplicate(true),
+		"connections": connections.duplicate(true)
+	}
+
+# Reverse graph cleared operation
+func _reverse_graph_cleared(operation: Dictionary) -> void:
+	# This would restore all nodes and connections in the graph editor
+	pass
+
+# Get connections for a node
+func _get_node_connections(node_name: String) -> Array:
+	# This would retrieve all connections to/from the node
+	return []