progress.

addons/cutscene_editor/editor/CutsceneGenerator.gd

@@ -0,0 +1,312 @@
+@tool
+class_name CutsceneGenerator
+extends Object
+
+# System for generating executable cutscene code from graph data
+
+# Properties
+var graph_nodes: Dictionary = {}  # Map of node names to node data
+var connections: Array = []       # List of connection data
+var logical_connections: Array = []  # Logical connections for parallel groups
+var node_instances: Dictionary = {}  # Map of node names to instantiated nodes
+
+# Generate a cutscene from graph data
+func generate_cutscene(cutscene_resource: CutsceneResource) -> CutsceneManager:
+	# Clear previous data
+	graph_nodes.clear()
+	connections.clear()
+	logical_connections.clear()
+	node_instances.clear()
+	
+	# Load graph data
+	for node_data in cutscene_resource.nodes:
+		graph_nodes[node_data["name"]] = node_data
+	
+	connections = cutscene_resource.connections
+	
+	# Load logical connections if they exist
+	if cutscene_resource.has_method("get_parallel_connections"):
+		logical_connections = cutscene_resource.get_parallel_connections()
+	
+	# Create CutsceneManager
+	var cutscene_manager = CutsceneManager.new()
+	
+	# Find entry node
+	var entry_node = _find_entry_node()
+	if not entry_node:
+		printerr("No entry node found in cutscene")
+		return cutscene_manager
+	
+	# Build action sequence starting from entry node
+	_build_action_sequence(entry_node, cutscene_manager)
+	
+	return cutscene_manager
+
+# Find the entry node in the graph
+func _find_entry_node() -> Dictionary:
+	for node_name in graph_nodes:
+		var node_data = graph_nodes[node_name]
+		if node_data["type"] == "entry":
+			return node_data
+	return {}
+
+# Build action sequence from graph data
+func _build_action_sequence(start_node: Dictionary, cutscene_manager: CutsceneManager) -> void:
+	# Use a queue-based traversal to process nodes in order
+	var node_queue = []
+	var processed_nodes = {}
+	var next_connections = _get_outgoing_connections(start_node["name"])
+	
+	# Add initial connections to queue
+	for conn in next_connections:
+		node_queue.append(conn["to_node"])
+	
+	# Process nodes in order
+	while not node_queue.is_empty():
+		var current_node_name = node_queue.pop_front()
+		
+		# Skip if already processed
+		if processed_nodes.has(current_node_name):
+			continue
+		
+		# Mark as processed
+		processed_nodes[current_node_name] = true
+		
+		# Get node data
+		var node_data = graph_nodes.get(current_node_name, {})
+		if node_data.is_empty():
+			continue
+		
+		# Handle parallel groups specially
+		if node_data["type"] == "parallel":
+			_handle_parallel_group(node_data, cutscene_manager, node_queue)
+		else:
+			# Create action for regular nodes
+			var action = _create_action_from_node(node_data)
+			if action:
+				cutscene_manager.add_action(action)
+		
+		# Add next nodes to queue
+		var outgoing_connections = _get_outgoing_connections(current_node_name)
+		for conn in outgoing_connections:
+			if not processed_nodes.has(conn["to_node"]):
+				node_queue.append(conn["to_node"])
+
+# Handle parallel group nodes
+func _handle_parallel_group(parallel_node: Dictionary, cutscene_manager: CutsceneManager, node_queue: Array) -> void:
+	# Find all nodes connected to this parallel group
+	var parallel_actions = []
+	
+	# Look for logical connections to this parallel group
+	for conn in logical_connections:
+		if conn["to_node"] == parallel_node["name"] and conn.get("is_parallel", false):
+			var source_node_name = conn["from_node"]
+			var source_node_data = graph_nodes.get(source_node_name, {})
+			if not source_node_data.is_empty():
+				var action = _create_action_from_node(source_node_data)
+				if action:
+					parallel_actions.append(action)
+	
+	# Add parallel actions to cutscene manager
+	if not parallel_actions.is_empty():
+		cutscene_manager.add_parallel_actions(parallel_actions)
+	
+	# Add nodes connected to parallel group output to queue
+	var outgoing_connections = _get_outgoing_connections(parallel_node["name"])
+	for conn in outgoing_connections:
+		node_queue.append(conn["to_node"])
+
+# Create an action instance from node data
+func _create_action_from_node(node_data: Dictionary):
+	var parameters = node_data["parameters"]
+	
+	match node_data["type"]:
+		"move":
+			var character_path = parameters.get("character", "")
+			var target_x = parameters.get("target_x", 0.0)
+			var target_y = parameters.get("target_y", 0.0)
+			var speed = parameters.get("speed", 100.0)
+			
+			# In a real implementation, we would resolve the character path to an actual node
+			# For now, we'll create a placeholder
+			var character_node = null  # This would be resolved at runtime
+			var target_position = Vector2(target_x, target_y)
+			
+			return MoveAction.new(character_node, target_position, speed)
+		
+		"turn":
+			var character_path = parameters.get("character", "")
+			var target = parameters.get("target", "")
+			var turn_speed = parameters.get("turn_speed", 2.0)
+			
+			# In a real implementation, we would resolve the paths to actual nodes
+			var character_node = null  # This would be resolved at runtime
+			var target_node = null      # This would be resolved at runtime
+			
+			return TurnAction.new(character_node, target_node, turn_speed)
+		
+		"dialogue":
+			var character_path = parameters.get("character", "")
+			var text = parameters.get("text", "")
+			var duration = parameters.get("duration", 0.0)
+			
+			var character_node = null  # This would be resolved at runtime
+			
+			return DialogueAction.new(character_node, text, duration)
+		
+		"animation":
+			var character_path = parameters.get("character", "")
+			var animation_name = parameters.get("animation_name", "")
+			var loop = parameters.get("loop", false)
+			
+			var character_node = null  # This would be resolved at runtime
+			
+			return AnimationAction.new(character_node, animation_name, loop)
+		
+		"wait":
+			var duration = parameters.get("duration", 1.0)
+			return WaitAction.new(duration)
+		
+		_:
+			printerr("Unknown node type: %s" % node_data["type"])
+			return null
+
+# Get outgoing connections from a node
+func _get_outgoing_connections(node_name: String) -> Array:
+	var outgoing = []
+	for conn in connections:
+		if conn["from_node"] == node_name:
+			outgoing.append(conn)
+	return outgoing
+
+# Get incoming connections to a node
+func _get_incoming_connections(node_name: String) -> Array:
+	var incoming = []
+	for conn in connections:
+		if conn["to_node"] == node_name:
+			incoming.append(conn)
+	return incoming
+
+# Generate GDScript code from graph data (alternative output format)
+func generate_gdscript_code(cutscene_resource: CutsceneResource) -> String:
+	var code = "# Generated Cutscene Code\n"
+	code += "extends Node2D\n\n"
+	
+	# Add character variables
+	code += "# Character nodes\n"
+	# This would need to be determined from the graph data
+	code += "@onready var character1: Node2D = $Character1\n"
+	code += "@onready var character2: Node2D = $Character2\n\n"
+	
+	code += "# Cutscene manager\n"
+	code += "var cutscene_manager: CutsceneManager\n\n"
+	
+	code += "func _ready() -> void:\n"
+	code += "    # Initialize the cutscene system\n"
+	code += "    setup_cutscene()\n"
+	code += "    \n"
+	code += "    # Start the cutscene\n"
+	code += "    cutscene_manager.start()\n\n"
+	
+	code += "func setup_cutscene() -> void:\n"
+	code += "    # Create the cutscene manager\n"
+	code += "    cutscene_manager = CutsceneManager.new()\n"
+	code += "    add_child(cutscene_manager)\n"
+	code += "    \n"
+	
+	# Generate action sequence
+	var action_sequence = _generate_action_sequence_code(cutscene_resource)
+	code += action_sequence
+	
+	code += "\n"
+	code += "func _on_cutscene_completed() -> void:\n"
+	code += "    print(\"Cutscene completed!\")\n"
+	
+	return code
+
+# Generate action sequence code
+func _generate_action_sequence_code(cutscene_resource: CutsceneResource) -> String:
+	var code = ""
+	
+	# This is a simplified approach - a real implementation would need to
+	# properly traverse the graph and handle parallel groups
+	
+	# Find entry node and traverse from there
+	var entry_node = _find_entry_node_in_resource(cutscene_resource)
+	if entry_node.is_empty():
+		return code
+	
+	# For demonstration, we'll just generate code for each node in order
+	# A real implementation would need proper graph traversal
+	
+	for node_data in cutscene_resource.nodes:
+		if node_data["type"] == "entry" or node_data["type"] == "exit":
+			continue
+		
+		var action_code = _generate_action_code(node_data)
+		if not action_code.is_empty():
+			code += "    " + action_code + "\n"
+	
+	return code
+
+# Find entry node in resource
+func _find_entry_node_in_resource(cutscene_resource: CutsceneResource) -> Dictionary:
+	for node_data in cutscene_resource.nodes:
+		if node_data["type"] == "entry":
+			return node_data
+	return {}
+
+# Generate code for a single action
+func _generate_action_code(node_data: Dictionary) -> String:
+	var parameters = node_data["parameters"]
+	
+	match node_data["type"]:
+		"move":
+			var character = parameters.get("character", "character1")
+			var x = parameters.get("target_x", 0.0)
+			var y = parameters.get("target_y", 0.0)
+			var speed = parameters.get("speed", 100.0)
+			return "cutscene_manager.add_action(MoveAction.new(%s, Vector2(%f, %f), %f))" % [character, x, y, speed]
+		
+		"turn":
+			var character = parameters.get("character", "character1")
+			var target = parameters.get("target", "character2")
+			var speed = parameters.get("turn_speed", 2.0)
+			return "cutscene_manager.add_action(TurnAction.new(%s, %s, %f))" % [character, target, speed]
+		
+		"dialogue":
+			var character = parameters.get("character", "character1")
+			var text = parameters.get("text", "")
+			var duration = parameters.get("duration", 0.0)
+			# Escape quotes in text
+			var escaped_text = text.replace("\"", "\\\"")
+			return "cutscene_manager.add_action(DialogueAction.new(%s, \"%s\", %f))" % [character, escaped_text, duration]
+		
+		"animation":
+			var character = parameters.get("character", "character1")
+			var anim_name = parameters.get("animation_name", "")
+			var loop = "true" if parameters.get("loop", false) else "false"
+			return "cutscene_manager.add_action(AnimationAction.new(%s, \"%s\", %s))" % [character, anim_name, loop]
+		
+		"wait":
+			var duration = parameters.get("duration", 1.0)
+			return "cutscene_manager.add_action(WaitAction.new(%f))" % duration
+		
+		_:
+			return ""
+
+# Export to different formats
+func export_to_format(cutscene_resource: CutsceneResource, format: String) -> String:
+	match format:
+		"gdscript":
+			return generate_gdscript_code(cutscene_resource)
+		"json":
+			return _export_to_json(cutscene_resource)
+		_:
+			return ""
+
+# Export to JSON format
+func _export_to_json(cutscene_resource: CutsceneResource) -> String:
+	# Convert the resource to JSON
+	var json = JSON.new()
+	return json.stringify(cutscene_resource, "  ")

addons/cutscene_editor/editor/CutsceneGraphEdit.gd

@@ -0,0 +1,634 @@
+@tool
+class_name CutsceneGraphEdit
+extends GraphEdit
+
+# Main graph editor interface
+
+# Signals
+signal node_added(node)
+signal node_removed(node)
+signal connection_created(from_node, from_port, to_node, to_port)
+signal connection_removed(from_node, from_port, to_node, to_port)
+signal graph_changed()
+
+# Properties
+var node_counter: int = 0  # For generating unique node IDs
+var current_cutscene: CutsceneResource  # The cutscene being edited
+
+# Preview properties
+var preview_manager: PreviewManager
+var preview_panel: PreviewPanel
+
+# Undo/Redo properties
+var undo_redo_manager: UndoRedoManager
+
+# Called when the node is ready
+func _ready() -> void:
+	# Set up GraphEdit properties
+	set_right_disconnects(true)
+	set_show_grid(true)
+	set_snapping_enabled(true)
+	set_snapping_distance(20)
+	
+	# Connect to GraphEdit signals
+	connect("connection_request", _on_connection_request)
+	connect("disconnection_request", _on_disconnection_request)
+	connect("node_selected", _on_node_selected)
+	connect("node_unselected", _on_node_unselected)
+	connect("popup_request", _on_popup_request)
+	connect("connection_to_empty", _on_connection_to_empty)
+	connect("connection_from_empty", _on_connection_from_empty)
+	
+	
+	# Add mini-map
+	_setup_minimap()
+
+
+# Set up mini-map
+func _setup_minimap() -> void:
+	# Enable mini-map
+	set_minimap_enabled(true)
+	set_minimap_size(Vector2(200, 150))
+	#set_minimap_offset(Vector2(10, 10))
+
+# Add a new node to the graph
+func add_node(node_type: String, position: Vector2) -> BaseGraphNode:
+	var new_node: BaseGraphNode
+	
+	match node_type:
+		"entry":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/EntryNode.gd").new()
+		"exit":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/ExitNode.gd").new()
+		"move":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/MoveActionNode.gd").new()
+		"turn":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/TurnActionNode.gd").new()
+		"dialogue":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/DialogueActionNode.gd").new()
+		"animation":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/AnimationActionNode.gd").new()
+		"wait":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/WaitActionNode.gd").new()
+		"parallel":
+			new_node = preload("res://addons/cutscene_editor/editor/nodes/ParallelGroupNode.gd").new()
+		_:
+			return null
+	
+	# Set node position
+	new_node.position_offset = position
+	
+	# Special handling for parallel groups
+	if new_node is ParallelGroupNode:
+		# Set a larger initial size for parallel groups
+		new_node.custom_minimum_size = Vector2(200, 150)
+	
+	# Add to GraphEdit
+	add_child(new_node)
+	
+	# Connect node signals
+	new_node.connect("node_selected", _on_graph_node_selected)
+	new_node.connect("node_deleted", _on_graph_node_deleted)
+	new_node.connect("parameter_changed", _on_node_parameter_changed)
+	
+	# Emit signal
+	emit_signal("node_added", new_node)
+	emit_signal("graph_changed")
+	
+	return new_node
+
+# Handle connection requests
+func _on_connection_request(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	# Validate connection before creating it
+	if _is_connection_valid(from_node, from_port, to_node, to_port):
+		# Get node references
+		var from_node_instance = get_node_or_null(from_node)
+		var to_node_instance = get_node_or_null(to_node)
+		
+		# Special handling for parallel groups
+		if to_node_instance is ParallelGroupNode:
+			# Connecting to a parallel group
+			if _is_valid_parallel_connection(from_node_instance, from_port, to_node_instance, to_port):
+				# Add child node to parallel group
+				if to_node_instance.can_add_child_node(from_node_instance):
+					to_node_instance.add_child_node(from_node_instance)
+					
+					# Create a logical connection (not visual)
+					_create_logical_parallel_connection(from_node, from_port, to_node, to_port)
+					
+					# Emit signal
+					emit_signal("connection_created", from_node, from_port, to_node, to_port)
+					emit_signal("graph_changed")
+					return
+		
+		# Create the connection
+		connect_node(from_node, from_port, to_node, to_port)
+		
+		# Emit signal
+		emit_signal("connection_created", from_node, from_port, to_node, to_port)
+		emit_signal("graph_changed")
+	else:
+		# Show error feedback
+		_show_connection_error(from_node, from_port, to_node, to_port)
+
+# Handle disconnection requests
+func _on_disconnection_request(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	# Get node references
+	var from_node_instance = get_node_or_null(from_node)
+	var to_node_instance = get_node_or_null(to_node)
+	
+	# Special handling for parallel groups
+	if to_node_instance is ParallelGroupNode:
+		# Remove child node from parallel group
+		if from_node_instance in to_node_instance.child_nodes:
+			to_node_instance.remove_child_node(from_node_instance)
+			
+			# Remove logical connection
+			_remove_logical_parallel_connection(from_node, from_port, to_node, to_port)
+			
+			# Emit signal
+			emit_signal("connection_removed", from_node, from_port, to_node, to_port)
+			emit_signal("graph_changed")
+			return
+	
+	# Remove the connection
+	disconnect_node(from_node, from_port, to_node, to_port)
+	
+	# Emit signal
+	emit_signal("connection_removed", from_node, from_port, to_node, to_port)
+	emit_signal("graph_changed")
+
+# Validate if a connection is valid
+func _is_connection_valid(from_node_name: String, from_port: int, to_node_name: String, to_port: int) -> bool:
+	# Get node references
+	var from_node = get_node_or_null(from_node_name)
+	var to_node = get_node_or_null(to_node_name)
+	
+	if not from_node or not to_node:
+		return false
+	
+	# Prevent connections to self
+	if from_node == to_node:
+		return false
+	
+	# Prevent duplicate connections
+	if is_node_connected(from_node_name, from_port, to_node_name, to_port):
+		return false
+	
+	# Prevent circular dependencies
+	if _would_create_cycle(from_node_name, to_node_name):
+		return false
+	
+	# Validate connection based on node types
+	match from_node.node_type:
+		"entry":
+			# Entry can connect to any node except entry/exit
+			return to_node.node_type != "entry" and to_node.node_type != "exit"
+		"exit":
+			# Exit cannot have outgoing connections
+			return false
+		"parallel":
+			# Parallel group output can connect to any node except entry/parallel
+			if from_port == from_node.input_connections:  # Output port
+				return to_node.node_type != "entry" and to_node.node_type != "parallel"
+			else:  # Input port
+				return to_node.node_type != "exit" and to_node.node_type != "parallel"
+		_:
+			# Other nodes can connect to any node except entry
+			return to_node.node_type != "entry"
+	
+	return true
+
+# Check if creating a connection would create a cycle
+func _would_create_cycle(from_node_name: String, to_node_name: String) -> bool:
+	# Simple cycle detection using depth-first search
+	var visited = {}
+	var recursion_stack = {}
+	
+	# Start from the target node and see if we can reach the source node
+	return _dfs_cycle_check(to_node_name, from_node_name, visited, recursion_stack)
+
+# Depth-first search for cycle detection
+func _dfs_cycle_check(current_node_name: String, target_node_name: String, visited: Dictionary, recursion_stack: Dictionary) -> bool:
+	# Mark current node as visited and add to recursion stack
+	visited[current_node_name] = true
+	recursion_stack[current_node_name] = true
+	
+	# Check all outgoing connections
+	for connection in get_connection_list():
+		if connection["from_node"] == current_node_name:
+			var next_node_name = connection["to_node"]
+			
+			# If we reached the target node, we found a cycle
+			if next_node_name == target_node_name:
+				return true
+			
+			# If next node not visited, recursively check
+			if not visited.has(next_node_name):
+				if _dfs_cycle_check(next_node_name, target_node_name, visited, recursion_stack):
+					return true
+			# If next node is in recursion stack, we found a cycle
+			elif recursion_stack.has(next_node_name):
+				return true
+	
+	# Check parallel connections
+	if has_meta("logical_connections"):
+		var logical_connections = get_meta("logical_connections")
+		for connection in logical_connections:
+			if connection["from_node"] == current_node_name:
+				var next_node_name = connection["to_node"]
+				
+				# If we reached the target node, we found a cycle
+				if next_node_name == target_node_name:
+					return true
+				
+				# If next node not visited, recursively check
+				if not visited.has(next_node_name):
+					if _dfs_cycle_check(next_node_name, target_node_name, visited, recursion_stack):
+						return true
+				# If next node is in recursion stack, we found a cycle
+				elif recursion_stack.has(next_node_name):
+					return true
+	
+	# Remove from recursion stack
+	recursion_stack[current_node_name] = false
+	return false
+
+# Show connection error feedback
+func _show_connection_error(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	# Visual feedback for invalid connection
+	# This could be a temporary red highlight or a popup message
+	print("Invalid connection: %s -> %s" % [from_node, to_node])
+
+# Handle popup request (right-click context menu)
+func _on_popup_request(position: Vector2) -> void:
+	# Create context menu for adding nodes
+	var menu = PopupMenu.new()
+	menu.name = "NodeContextMenu"
+	
+	# Add node types to menu
+	menu.add_item("Add Entry Node", 0)
+	menu.add_item("Add Exit Node", 1)
+	menu.add_item("Add Move Action", 2)
+	menu.add_item("Add Turn Action", 3)
+	menu.add_item("Add Dialogue Action", 4)
+	menu.add_item("Add Animation Action", 5)
+	menu.add_item("Add Wait Action", 6)
+	menu.add_item("Add Parallel Group", 7)
+	
+	# Connect menu signals
+	menu.connect("id_pressed", _on_context_menu_selected.bind(position))
+	
+	# Add menu to scene and show it
+	add_child(menu)
+	menu.position = position
+	menu.popup()
+
+# Handle context menu selection
+func _on_context_menu_selected(id: int, position: Vector2) -> void:
+	var node_type: String
+	
+	match id:
+		0:
+			node_type = "entry"
+		1:
+			node_type = "exit"
+		2:
+			node_type = "move"
+		3:
+			node_type = "turn"
+		4:
+			node_type = "dialogue"
+		5:
+			node_type = "animation"
+		6:
+			node_type = "wait"
+		7:
+			node_type = "parallel"
+		_:
+			return
+	
+	# Add the selected node type
+	add_node(node_type, position)
+
+# Handle zoom in
+func _on_zoom_in_pressed() -> void:
+	# Increase zoom level
+	zoom *= 1.2
+	_update_zoom_label()
+
+# Handle zoom out
+func _on_zoom_out_pressed() -> void:
+	# Decrease zoom level
+	zoom /= 1.2
+	_update_zoom_label()
+
+# Update zoom label
+func _update_zoom_label() -> void:
+	var zoom_label = get_node_or_null("ZoomControls/ZoomLabel")
+	if zoom_label:
+		zoom_label.text = "%d%%" % (zoom * 100)
+
+# Handle node selection
+func _on_node_selected(node_name: String) -> void:
+	# Handle GraphEdit's built-in node selection
+	pass
+
+# Handle node unselection
+func _on_node_unselected(node_name: String) -> void:
+	# Handle GraphEdit's built-in node unselection
+	pass
+
+# Handle graph node selection
+func _on_graph_node_selected(node: BaseGraphNode) -> void:
+	# Handle custom node selection
+	pass
+
+# Handle graph node deletion
+func _on_graph_node_deleted(node: BaseGraphNode) -> void:
+	# Special handling for parallel groups
+	if node is ParallelGroupNode:
+		# Remove all child nodes first
+		for child_node in node.child_nodes:
+			# Remove child from scene tree
+			if child_node.get_parent():
+				child_node.get_parent().remove_child(child_node)
+			
+			# Add child back to main graph
+			add_child(child_node)
+			
+			# Update child position to be near the parallel group
+			child_node.position_offset = node.position_offset + Vector2(50, 50)
+		
+		# Clear child nodes array
+		node.child_nodes.clear()
+	
+	# Remove all connections to/from this node
+	var connections = get_connection_list()
+	for connection in connections:
+		if connection["from_node"] == node.name or connection["to_node"] == node.name:
+			disconnect_node(connection["from_node"], connection["from_port"], connection["to_node"], connection["to_port"])
+	
+	# Remove logical connections for parallel groups
+	if has_meta("logical_connections"):
+		var logical_connections = get_meta("logical_connections")
+		var i = 0
+		while i < logical_connections.size():
+			var conn = logical_connections[i]
+			if conn["from_node"] == node.name or conn["to_node"] == node.name:
+				logical_connections.remove_at(i)
+			else:
+				i += 1
+	
+	# Remove node from GraphEdit
+	remove_child(node)
+	
+	# Emit signals
+	emit_signal("node_removed", node)
+	emit_signal("graph_changed")
+
+# Handle node parameter changes
+func _on_node_parameter_changed(node: BaseGraphNode, parameter_name: String, new_value) -> void:
+	# Handle parameter changes in nodes
+	emit_signal("graph_changed")
+
+# Handle connection to empty space
+func _on_connection_to_empty(from_node: String, from_port: int, release_position: Vector2) -> void:
+	# This could be used to show a menu or create a new node
+	pass
+
+# Handle connection from empty space
+func _on_connection_from_empty(to_node: String, to_port: int, release_position: Vector2) -> void:
+	# This could be used to show a menu or create a new node
+	pass
+
+# Clear the graph
+func clear_graph() -> void:
+	# Remove all nodes
+	for child in get_children():
+		if child is BaseGraphNode:
+			remove_child(child)
+			child.queue_free()
+	
+	# Clear all connections
+	clear_connections()
+	
+	# Reset node counter
+	node_counter = 0
+	
+	# Emit signal
+	emit_signal("graph_changed")
+
+# Load graph from cutscene resource
+func load_from_cutscene(cutscene: CutsceneResource) -> void:
+	# Clear existing graph
+	clear_graph()
+	
+	# Set current cutscene
+	current_cutscene = cutscene
+	
+	# Create nodes from cutscene data
+	for node_data in cutscene.nodes:
+		var node = add_node(node_data["type"], Vector2(node_data["x"], node_data["y"]))
+		if node:
+			node.name = node_data["name"]
+			# Set node parameters
+			for param_name in node_data["parameters"]:
+				node.set_parameter(param_name, node_data["parameters"][param_name])
+	
+	# Create connections from cutscene data
+	for connection_data in cutscene.connections:
+		connect_node(connection_data["from_node"], connection_data["from_port"], 
+					 connection_data["to_node"], connection_data["to_port"])
+	
+	# Emit signal
+	emit_signal("graph_changed")
+
+# Save graph to cutscene resource
+func save_to_cutscene() -> CutsceneResource:
+	if not current_cutscene:
+		current_cutscene = preload("res://addons/cutscene_editor/editor/resources/CutsceneResource.gd").new()
+	
+	# Clear existing data
+	current_cutscene.nodes.clear()
+	current_cutscene.connections.clear()
+	
+	# Save nodes
+	for child in get_children():
+		if child is BaseGraphNode:
+			var node_data = {
+				"name": child.name,
+				"type": child.node_type,
+				"x": child.position_offset.x,
+				"y": child.position_offset.y,
+				"parameters": child.action_parameters
+			}
+			current_cutscene.nodes.append(node_data)
+	
+	# Save connections
+	for connection in get_connection_list():
+		var connection_data = {
+			"from_node": connection["from_node"],
+			"from_port": connection["from_port"],
+			"to_node": connection["to_node"],
+			"to_port": connection["to_port"]
+		}
+		current_cutscene.connections.append(connection_data)
+	
+	return current_cutscene
+
+# Special handling for parallel groups
+func _is_valid_parallel_connection(from_node: BaseGraphNode, from_port: int, to_node: ParallelGroupNode, to_port: int) -> bool:
+	# Can only connect to input ports of parallel groups
+	if to_port >= to_node.input_connections:
+		return false
+	
+	# Can't connect parallel group to itself
+	if from_node == to_node:
+		return false
+	
+	# Can't connect entry or exit nodes to parallel groups
+	if from_node.node_type == "entry" or from_node.node_type == "exit":
+		return false
+	
+	# Can't connect parallel groups to parallel groups
+	if from_node.node_type == "parallel":
+		return false
+	
+	return true
+
+# Create a logical connection for parallel groups (not visually represented)
+func _create_logical_parallel_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	# Store the logical connection in our data structure
+	# This connection won't be visually represented but will be used for generation
+	var logical_connection = {
+		"from_node": from_node,
+		"from_port": from_port,
+		"to_node": to_node,
+		"to_port": to_port,
+		"is_parallel": true
+	}
+	
+	# Add to a separate list of logical connections
+	if not has_meta("logical_connections"):
+		set_meta("logical_connections", [])
+	
+	var logical_connections = get_meta("logical_connections")
+	logical_connections.append(logical_connection)
+
+# Remove a logical connection for parallel groups
+func _remove_logical_parallel_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	if not has_meta("logical_connections"):
+		return
+	
+	var logical_connections = get_meta("logical_connections")
+	var i = 0
+	while i < logical_connections.size():
+		var conn = logical_connections[i]
+		if (conn["from_node"] == from_node and conn["from_port"] == from_port and
+			conn["to_node"] == to_node and conn["to_port"] == to_port):
+			logical_connections.remove_at(i)
+			return
+		i += 1
+
+# Get all logical connections
+func get_logical_connections() -> Array:
+	if has_meta("logical_connections"):
+		return get_meta("logical_connections")
+	return []
+
+# Set up preview system
+func setup_preview() -> void:
+	# Create preview manager
+	preview_manager = PreviewManager.new()
+	add_child(preview_manager)
+	
+	# Create preview panel
+	preview_panel = PreviewPanel.new()
+	preview_panel.set_preview_manager(preview_manager)
+	preview_panel.set_graph_edit(self)
+	
+	# Add to editor interface (this would be added to the editor UI)
+	# For now, we'll just keep a reference to it
+
+# Start preview
+func start_preview() -> void:
+	if preview_manager:
+		preview_manager.start_preview()
+
+# Stop preview
+func stop_preview() -> void:
+	if preview_manager:
+		preview_manager.stop_preview()
+
+# Pause preview
+func pause_preview() -> void:
+	if preview_manager:
+		preview_manager.pause_preview()
+
+# Resume preview
+func resume_preview() -> void:
+	if preview_manager:
+		preview_manager.resume_preview()
+
+# Set up undo/redo system
+func _setup_undo_redo() -> void:
+	# Create undo/redo manager
+	undo_redo_manager = UndoRedoManager.new()
+	undo_redo_manager.connect("undo_redo_state_changed", _on_undo_redo_state_changed)
+	
+	# Connect to existing signals
+	connect("node_added", _on_node_added_for_undo)
+	connect("node_removed", _on_node_removed_for_undo)
+	connect("connection_created", _on_connection_created_for_undo)
+	connect("connection_removed", _on_connection_removed_for_undo)
+	connect("graph_changed", _on_graph_changed_for_undo)
+
+# Handle node added for undo
+func _on_node_added_for_undo(node: BaseGraphNode) -> void:
+	if undo_redo_manager:
+		var operation = undo_redo_manager.create_node_added_operation(node)
+		undo_redo_manager.add_operation(operation)
+
+# Handle node removed for undo
+func _on_node_removed_for_undo(node: BaseGraphNode) -> void:
+	if undo_redo_manager:
+		var operation = undo_redo_manager.create_node_removed_operation(node)
+		undo_redo_manager.add_operation(operation)
+
+# Handle connection created for undo
+func _on_connection_created_for_undo(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	if undo_redo_manager:
+		var operation = undo_redo_manager.create_connection_created_operation(from_node, from_port, to_node, to_port)
+		undo_redo_manager.add_operation(operation)
+
+# Handle connection removed for undo
+func _on_connection_removed_for_undo(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	if undo_redo_manager:
+		var operation = undo_redo_manager.create_connection_removed_operation(from_node, from_port, to_node, to_port)
+		undo_redo_manager.add_operation(operation)
+
+# Handle graph changed for undo
+func _on_graph_changed_for_undo() -> void:
+	# This could be used for batch operations or complex changes
+	pass
+
+# Handle undo/redo state changed
+func _on_undo_redo_state_changed() -> void:
+	# Update UI to reflect undo/redo availability
+	_update_undo_redo_ui()
+
+# Update undo/redo UI
+func _update_undo_redo_ui() -> void:
+	# This would update toolbar buttons or menu items
+	pass
+
+# Perform undo operation
+func undo() -> void:
+	if undo_redo_manager and undo_redo_manager.can_undo():
+		undo_redo_manager.undo()
+
+# Perform redo operation
+func redo() -> void:
+	if undo_redo_manager and undo_redo_manager.can_redo():
+		undo_redo_manager.redo()

addons/cutscene_editor/editor/PreviewManager.gd

@@ -0,0 +1,274 @@
+@tool
+class_name PreviewManager
+extends Node
+
+# Manager for real-time cutscene preview
+
+# Signals
+signal preview_started()
+signal preview_stopped()
+signal preview_paused()
+signal preview_resumed()
+signal preview_progress(progress: float)
+signal node_activated(node_name: String)
+signal node_completed(node_name: String)
+
+# Properties
+var is_previewing: bool = false
+var is_paused: bool = false
+var current_cutscene: CutsceneManager
+var preview_scene: Node2D  # The scene being previewed
+var preview_characters: Dictionary = {}  # Map of character names to nodes
+var graph_edit: CutsceneGraphEdit  # Reference to the graph editor
+
+# Preview settings
+var preview_speed: float = 1.0
+var show_debug_info: bool = true
+
+# Initialize the preview manager
+func _init() -> void:
+	name = "PreviewManager"
+
+# Set up the preview with a graph editor
+func setup_preview(graph: CutsceneGraphEdit) -> void:
+	graph_edit = graph
+	
+	# Connect to graph change signals
+	if graph_edit:
+		graph_edit.connect("graph_changed", _on_graph_changed)
+
+# Start the preview
+func start_preview() -> void:
+	if is_previewing:
+		return
+	
+	# Create preview scene
+	_setup_preview_scene()
+	
+	# Generate cutscene from current graph
+	var cutscene_resource = graph_edit.save_to_cutscene()
+	var generator = CutsceneGenerator.new()
+	current_cutscene = generator.generate_cutscene(cutscene_resource)
+	
+	# Add cutscene to preview scene
+	if preview_scene and current_cutscene:
+		preview_scene.add_child(current_cutscene)
+		
+		# Connect to cutscene signals for feedback
+		_connect_cutscene_signals()
+		
+		# Start the cutscene
+		current_cutscene.start()
+		
+		# Update state
+		is_previewing = true
+		is_paused = false
+		emit_signal("preview_started")
+
+# Stop the preview
+func stop_preview() -> void:
+	if not is_previewing:
+		return
+	
+	# Stop the cutscene
+	if current_cutscene:
+		current_cutscene.stop()
+		_disconnect_cutscene_signals()
+		
+		# Remove from preview scene
+		if current_cutscene.get_parent() == preview_scene:
+			preview_scene.remove_child(current_cutscene)
+			current_cutscene.queue_free()
+	
+	# Clean up preview scene
+	_cleanup_preview_scene()
+	
+	# Update state
+	is_previewing = false
+	is_paused = false
+	emit_signal("preview_stopped")
+
+# Pause the preview
+func pause_preview() -> void:
+	if not is_previewing or is_paused:
+		return
+	
+	if current_cutscene:
+		current_cutscene.pause()
+		is_paused = true
+		emit_signal("preview_paused")
+
+# Resume the preview
+func resume_preview() -> void:
+	if not is_previewing or not is_paused:
+		return
+	
+	if current_cutscene:
+		current_cutscene.resume()
+		is_paused = false
+		emit_signal("preview_resumed")
+
+# Set preview speed
+func set_preview_speed(speed: float) -> void:
+	preview_speed = speed
+	# In a real implementation, this would affect the time scale
+	# of the preview scene
+
+# Set up the preview scene
+func _setup_preview_scene() -> void:
+	# Create or reuse preview scene
+	if not preview_scene:
+		preview_scene = Node2D.new()
+		preview_scene.name = "PreviewScene"
+		add_child(preview_scene)
+	
+	# Set up characters for preview
+	_setup_preview_characters()
+
+# Set up characters for preview
+func _setup_preview_characters() -> void:
+	# Clear existing characters
+	preview_characters.clear()
+	
+	# Create placeholder characters for preview
+	# In a real implementation, this would load actual character scenes
+	var character1 = _create_preview_character("Character1", Vector2(100, 100))
+	var character2 = _create_preview_character("Character2", Vector2(200, 100))
+	
+	preview_characters["Character1"] = character1
+	preview_characters["Character2"] = character2
+	
+	# Add to preview scene
+	if preview_scene:
+		preview_scene.add_child(character1)
+		preview_scene.add_child(character2)
+
+# Create a preview character
+func _create_preview_character(name: String, position: Vector2) -> Node2D:
+	var character = Node2D.new()
+	character.name = name
+	character.position = position
+	
+	# Add a visual representation
+	var sprite = Polygon2D.new()
+	sprite.polygon = PackedVector2Array([
+		Vector2(-10, -20),
+		Vector2(-30, 0),
+		Vector2(-10, 20),
+		Vector2(10, 20),
+		Vector2(30, 0),
+		Vector2(10, -20)
+	])
+	sprite.color = Color(0.5, 0.7, 1.0)
+	character.add_child(sprite)
+	
+	return character
+
+# Clean up the preview scene
+func _cleanup_preview_scene() -> void:
+	# Remove characters
+	for char_name in preview_characters:
+		var character = preview_characters[char_name]
+		if character.get_parent() == preview_scene:
+			preview_scene.remove_child(character)
+			character.queue_free()
+	
+	preview_characters.clear()
+
+# Connect to cutscene signals for feedback
+func _connect_cutscene_signals() -> void:
+	if not current_cutscene:
+		return
+	
+	# Disconnect existing connections
+	_disconnect_cutscene_signals()
+	
+	# Connect to signals
+	current_cutscene.connect("cutscene_started", _on_cutscene_started)
+	current_cutscene.connect("cutscene_completed", _on_cutscene_completed)
+	current_cutscene.connect("cutscene_paused", _on_cutscene_paused)
+	current_cutscene.connect("cutscene_resumed", _on_cutscene_resumed)
+	current_cutscene.connect("action_started", _on_action_started)
+	current_cutscene.connect("action_completed", _on_action_completed)
+
+# Disconnect from cutscene signals
+func _disconnect_cutscene_signals() -> void:
+	if not current_cutscene:
+		return
+	
+	if current_cutscene.is_connected("cutscene_started", _on_cutscene_started):
+		current_cutscene.disconnect("cutscene_started", _on_cutscene_started)
+	if current_cutscene.is_connected("cutscene_completed", _on_cutscene_completed):
+		current_cutscene.disconnect("cutscene_completed", _on_cutscene_completed)
+	if current_cutscene.is_connected("cutscene_paused", _on_cutscene_paused):
+		current_cutscene.disconnect("cutscene_paused", _on_cutscene_paused)
+	if current_cutscene.is_connected("cutscene_resumed", _on_cutscene_resumed):
+		current_cutscene.disconnect("cutscene_resumed", _on_cutscene_resumed)
+	if current_cutscene.is_connected("action_started", _on_action_started):
+		current_cutscene.disconnect("action_started", _on_action_started)
+	if current_cutscene.is_connected("action_completed", _on_action_completed):
+		current_cutscene.disconnect("action_completed", _on_action_completed)
+
+# Handle graph changes
+func _on_graph_changed() -> void:
+	# If we're previewing, restart the preview to reflect changes
+	if is_previewing:
+		stop_preview()
+		start_preview()
+
+# Handle cutscene started
+func _on_cutscene_started() -> void:
+	emit_signal("preview_started")
+
+# Handle cutscene completed
+func _on_cutscene_completed() -> void:
+	emit_signal("preview_stopped")
+	is_previewing = false
+	is_paused = false
+
+# Handle cutscene paused
+func _on_cutscene_paused() -> void:
+	emit_signal("preview_paused")
+	is_paused = true
+
+# Handle cutscene resumed
+func _on_cutscene_resumed() -> void:
+	emit_signal("preview_resumed")
+	is_paused = false
+
+# Handle action started
+func _on_action_started(action: Action) -> void:
+	# Find the corresponding node in the graph and highlight it
+	var node_name = _find_node_for_action(action)
+	if node_name:
+		emit_signal("node_activated", node_name)
+		
+		# Update graph editor visualization
+		if graph_edit:
+			var node = graph_edit.get_node_or_null(node_name)
+			if node and node.has_method("set_state"):
+				node.set_state(BaseGraphNode.NodeState.ACTIVE)
+
+# Handle action completed
+func _on_action_completed(action: Action) -> void:
+	# Find the corresponding node in the graph and mark as completed
+	var node_name = _find_node_for_action(action)
+	if node_name:
+		emit_signal("node_completed", node_name)
+		
+		# Update graph editor visualization
+		if graph_edit:
+			var node = graph_edit.get_node_or_null(node_name)
+			if node and node.has_method("set_state"):
+				node.set_state(BaseGraphNode.NodeState.COMPLETED)
+
+# Find node corresponding to an action
+func _find_node_for_action(action: Action) -> String:
+	# This would need to map actions to nodes
+	# In a real implementation, we would store this mapping when generating the cutscene
+	# For now, we'll return a placeholder
+	return ""
+
+# Get the preview scene for display
+func get_preview_scene() -> Node2D:
+	return preview_scene

addons/cutscene_editor/editor/PreviewPanel.gd

@@ -0,0 +1,186 @@
+@tool
+class_name PreviewPanel
+extends PanelContainer
+
+# UI panel for displaying the preview
+
+# UI elements
+var preview_viewport: SubViewport
+var preview_texture: TextureRect
+var controls_container: HBoxContainer
+var play_button: Button
+var pause_button: Button
+var stop_button: Button
+var speed_slider: HSlider
+var progress_bar: ProgressBar
+var debug_label: Label
+
+# Properties
+var preview_manager: PreviewManager
+var is_playing: bool = false
+
+# Initialize the preview panel
+func _ready() -> void:
+	_setup_ui()
+	_setup_signals()
+
+# Set up the UI
+func _setup_ui() -> void:
+	# Main container
+	var main_vbox = VBoxContainer.new()
+	main_vbox.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	main_vbox.size_flags_vertical = Control.SIZE_EXPAND_FILL
+	add_child(main_vbox)
+	
+	# Preview viewport
+	var viewport_container = AspectRatioContainer.new()
+	viewport_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	viewport_container.size_flags_vertical = Control.SIZE_EXPAND_FILL
+	viewport_container.ratio = 16.0/9.0
+	main_vbox.add_child(viewport_container)
+	
+	preview_viewport = SubViewport.new()
+	preview_viewport.size = Vector2i(800, 450)
+	preview_viewport.render_target_update_mode = SubViewport.UPDATE_ALWAYS
+	viewport_container.add_child(preview_viewport)
+	
+	preview_texture = TextureRect.new()
+	preview_texture.expand = true
+	preview_texture.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	preview_texture.size_flags_vertical = Control.SIZE_EXPAND_FILL
+	preview_texture.texture = preview_viewport.get_texture()
+	viewport_container.add_child(preview_texture)
+	
+	# Controls
+	controls_container = HBoxContainer.new()
+	controls_container.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	main_vbox.add_child(controls_container)
+	
+	play_button = Button.new()
+	play_button.text = "▶"
+	play_button.flat = true
+	controls_container.add_child(play_button)
+	
+	pause_button = Button.new()
+	pause_button.text = "⏸"
+	pause_button.flat = true
+	controls_container.add_child(pause_button)
+	
+	stop_button = Button.new()
+	stop_button.text = "⏹"
+	stop_button.flat = true
+	controls_container.add_child(stop_button)
+	
+	var speed_label = Label.new()
+	speed_label.text = "Speed:"
+	controls_container.add_child(speed_label)
+	
+	speed_slider = HSlider.new()
+	speed_slider.min = 0.1
+	speed_slider.max = 2.0
+	speed_slider.step = 0.1
+	speed_slider.value = 1.0
+	speed_slider.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	controls_container.add_child(speed_slider)
+	
+	# Progress bar
+	progress_bar = ProgressBar.new()
+	progress_bar.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	progress_bar.percent_visible = true
+	main_vbox.add_child(progress_bar)
+	
+	# Debug info
+	debug_label = Label.new()
+	debug_label.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	main_vbox.add_child(debug_label)
+
+# Set up signal connections
+func _setup_signals() -> void:
+	play_button.connect("pressed", _on_play_pressed)
+	pause_button.connect("pressed", _on_pause_pressed)
+	stop_button.connect("pressed", _on_stop_pressed)
+	speed_slider.connect("value_changed", _on_speed_changed)
+
+# Set the preview manager
+func set_preview_manager(manager: PreviewManager) -> void:
+	preview_manager = manager
+	
+	# Connect to preview manager signals
+	if preview_manager:
+		preview_manager.connect("preview_started", _on_preview_started)
+		preview_manager.connect("preview_stopped", _on_preview_stopped)
+		preview_manager.connect("preview_paused", _on_preview_paused)
+		preview_manager.connect("preview_resumed", _on_preview_resumed)
+		preview_manager.connect("preview_progress", _on_preview_progress)
+		preview_manager.connect("node_activated", _on_node_activated)
+		preview_manager.connect("node_completed", _on_node_completed)
+
+# Set the graph editor
+func set_graph_edit(graph_edit: CutsceneGraphEdit) -> void:
+	if preview_manager:
+		preview_manager.setup_preview(graph_edit)
+		
+		# Add preview scene to viewport
+		var preview_scene = preview_manager.get_preview_scene()
+		if preview_scene and preview_scene.get_parent() != preview_viewport:
+			preview_viewport.add_child(preview_scene)
+
+# Handle play button press
+func _on_play_pressed() -> void:
+	if preview_manager:
+		if is_playing:
+			preview_manager.resume_preview()
+		else:
+			preview_manager.start_preview()
+
+# Handle pause button press
+func _on_pause_pressed() -> void:
+	if preview_manager:
+		preview_manager.pause_preview()
+
+# Handle stop button press
+func _on_stop_pressed() -> void:
+	if preview_manager:
+		preview_manager.stop_preview()
+
+# Handle speed slider change
+func _on_speed_changed(value: float) -> void:
+	if preview_manager:
+		preview_manager.set_preview_speed(value)
+
+# Handle preview started
+func _on_preview_started() -> void:
+	is_playing = true
+	play_button.text = "⏸"
+	debug_label.text = "Preview started"
+
+# Handle preview stopped
+func _on_preview_stopped() -> void:
+	is_playing = false
+	play_button.text = "▶"
+	progress_bar.value = 0
+	debug_label.text = "Preview stopped"
+
+# Handle preview paused
+func _on_preview_paused() -> void:
+	is_playing = false
+	play_button.text = "▶"
+	debug_label.text = "Preview paused"
+
+# Handle preview resumed
+func _on_preview_resumed() -> void:
+	is_playing = true
+	play_button.text = "⏸"
+	debug_label.text = "Preview resumed"
+
+# Handle preview progress
+func _on_preview_progress(progress: float) -> void:
+	progress_bar.value = progress * 100
+
+# Handle node activated
+func _on_node_activated(node_name: String) -> void:
+	debug_label.text = "Executing: %s" % node_name
+
+# Handle node completed
+func _on_node_completed(node_name: String) -> void:
+	debug_label.text = "Completed: %s" % node_name

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 []

addons/cutscene_editor/editor/nodes/AnimationActionNode.gd

@@ -0,0 +1,62 @@
+@tool
+class_name AnimationActionNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for AnimationAction
+
+func _init() -> void:
+	node_type = "animation"
+	node_id = "animation_" + str(randi())
+	title = "Animation"
+	modulate = Color(0.8, 0.4, 0.8)  # Purple
+	
+	# One input and one output connection
+	var slot = 0
+	set_slot(slot, true, 0, Color(0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Initialize default parameters
+	action_parameters["character"] = ""
+	action_parameters["animation_name"] = ""
+	action_parameters["loop"] = false
+
+func _setup_parameter_fields() -> void:
+	# Character field
+	var char_label = Label.new()
+	char_label.text = "Character:"
+	add_child(char_label)
+	
+	var char_field = LineEdit.new()
+	char_field.text = action_parameters["character"]
+	char_field.connect("text_changed", _on_character_changed)
+	add_child(char_field)
+	
+	# Animation name field
+	var anim_label = Label.new()
+	anim_label.text = "Animation:"
+	add_child(anim_label)
+	
+	var anim_field = LineEdit.new()
+	anim_field.text = action_parameters["animation_name"]
+	anim_field.connect("text_changed", _on_animation_changed)
+	add_child(anim_field)
+	
+	# Loop checkbox
+	var loop_label = Label.new()
+	loop_label.text = "Loop:"
+	add_child(loop_label)
+	
+	var loop_checkbox = CheckBox.new()
+	loop_checkbox.button_pressed = action_parameters["loop"]
+	loop_checkbox.connect("toggled", _on_loop_toggled)
+	add_child(loop_checkbox)
+
+func _on_character_changed(new_text: String) -> void:
+	set_parameter("character", new_text)
+
+func _on_animation_changed(new_text: String) -> void:
+	set_parameter("animation_name", new_text)
+
+func _on_loop_toggled(button_pressed: bool) -> void:
+	set_parameter("loop", button_pressed)

addons/cutscene_editor/editor/nodes/BaseGraphNode.gd

@@ -0,0 +1,284 @@
+@tool
+class_name BaseGraphNode
+extends GraphNode
+
+# Base class for all cutscene graph nodes
+
+# Signals
+signal node_selected2(node)
+signal node_deleted(node)
+signal parameter_changed(node, parameter_name, new_value)
+
+# Node states
+enum NodeState {
+	IDLE,
+	ACTIVE,
+	COMPLETED,
+	ERROR,
+	PAUSED
+}
+
+# Properties
+var node_type: String = "base"
+var node_id: String  # Unique identifier for the node
+var action_parameters: Dictionary = {}  # Stores parameter values
+var current_state: int = NodeState.IDLE
+var error_message: String = ""
+var property_editors: Dictionary = {}  # Map of property names to editors
+
+# Visual feedback elements
+var state_border: ColorRect
+var overlay_icon: TextureRect
+var checkmark_texture: Texture2D
+var error_texture: Texture2D
+var pause_texture: Texture2D
+
+# Called when the node is ready
+func _ready() -> void:
+	# Set up common node properties
+	connect("dragged", _on_node_dragged)
+	connect("selected", _on_node_selected)
+	
+	# Add close butto
+	
+	# Set up visual feedback elements
+	_setup_visual_feedback()
+	
+	# Add parameter fields based on node type
+	_setup_parameter_fields()
+
+# Set up visual feedback elements
+func _setup_visual_feedback() -> void:
+	# Create state border
+	state_border = ColorRect.new()
+	state_border.name = "StateBorder"
+	state_border.anchor_right = 1
+	state_border.anchor_bottom = 1
+	state_border.margin_left = -2
+	state_border.margin_top = -2
+	state_border.margin_right = 2
+	state_border.margin_bottom = 2
+	state_border.color = Color(0, 0, 0, 0)  # Transparent by default
+	state_border.z_index = -1  # Behind the node
+	add_child(state_border)
+	
+	# Create overlay icon container
+	var overlay_container = CenterContainer.new()
+	overlay_container.name = "OverlayContainer"
+	overlay_container.anchor_right = 1
+	overlay_container.anchor_bottom = 1
+	overlay_container.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	add_child(overlay_container)
+	
+	# Create overlay icon
+	overlay_icon = TextureRect.new()
+	overlay_icon.name = "OverlayIcon"
+	overlay_icon.expand = true
+	overlay_icon.size_flags_horizontal = Control.SIZE_SHRINK_CENTER
+	overlay_icon.size_flags_vertical = Control.SIZE_SHRINK_CENTER
+	overlay_icon.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	overlay_container.add_child(overlay_icon)
+	
+	# Load textures (these would be actual textures in a real implementation)
+	# checkmark_texture = preload("res://addons/cutscene_editor/icons/checkmark.png")
+	# error_texture = preload("res://addons/cutscene_editor/icons/error.png")
+	# pause_texture = preload("res://addons/cutscene_editor/icons/pause.png")
+
+# Set up parameter fields based on node type
+func _setup_parameter_fields() -> void:
+	# This method should be overridden by subclasses
+	pass
+
+# Set node state and update visual feedback
+func set_state(new_state: int, error_msg: String = "") -> void:
+	current_state = new_state
+	error_message = error_msg
+	_update_visual_feedback()
+
+# Update visual feedback based on current state
+func _update_visual_feedback() -> void:
+	match current_state:
+		NodeState.IDLE:
+			_set_idle_state()
+		NodeState.ACTIVE:
+			_set_active_state()
+		NodeState.COMPLETED:
+			_set_completed_state()
+		NodeState.ERROR:
+			_set_error_state()
+		NodeState.PAUSED:
+			_set_paused_state()
+
+# Set idle state visuals
+func _set_idle_state() -> void:
+	# Reset to default appearance
+	state_border.color = Color(0, 0, 0, 0)
+	overlay_icon.texture = null
+	modulate = Color(1, 1, 1, 1)
+	scale = Vector2(1, 1)
+	
+	# Stop any animations
+	_stop_animations()
+
+# Set active state visuals
+func _set_active_state() -> void:
+	# White border highlight
+	state_border.color = Color(1, 1, 1, 1)
+	state_border.size = Vector2(2, 2)
+	
+	# Clear overlay
+	overlay_icon.texture = null
+	
+	# Start pulsing animation
+	_start_pulsing_animation()
+	
+	# Slight scale increase
+	scale = Vector2(1.05, 1.05)
+
+# Set completed state visuals
+func _set_completed_state() -> void:
+	# Green border
+	state_border.color = Color(0, 1, 0, 0.5)
+	state_border.size = Vector2(2, 2)
+	
+	# Checkmark overlay
+	overlay_icon.texture = checkmark_texture
+	overlay_icon.modulate = Color(0, 1, 0, 0.7)
+	
+	# Slight transparency
+	modulate = Color(1, 1, 1, 0.8)
+	
+	# Stop animations
+	_stop_animations()
+
+# Set error state visuals
+func _set_error_state() -> void:
+	# Red border
+	state_border.color = Color(1, 0, 0, 1)
+	state_border.size = Vector2(3, 3)
+	
+	# Error icon overlay
+	overlay_icon.texture = error_texture
+	overlay_icon.modulate = Color(1, 0, 0, 1)
+	
+	# Red tint
+	modulate = Color(1, 0.7, 0.7, 1)
+	
+	# Start shake animation
+	_start_shake_animation()
+
+# Set paused state visuals
+func _set_paused_state() -> void:
+	# Yellow border
+	state_border.color = Color(1, 1, 0, 1)
+	state_border.size = Vector2(2, 2)
+	
+	# Pause icon overlay
+	overlay_icon.texture = pause_texture
+	overlay_icon.modulate = Color(1, 1, 0, 1)
+	
+	# Stop animations
+	_stop_animations()
+
+# Animation functions
+func _start_pulsing_animation() -> void:
+	# Create animation player for pulsing effect
+	var anim_player = AnimationPlayer.new()
+	anim_player.name = "StateAnimationPlayer"
+	
+	# Remove existing animation player if present
+	var existing_player = get_node_or_null("StateAnimationPlayer")
+	if existing_player:
+		remove_child(existing_player)
+		existing_player.queue_free()
+	
+	add_child(anim_player)
+	
+	# Create pulsing animation
+	var animation = Animation.new()
+	animation.name = "pulse"
+	animation.length = 1.0
+	animation.loop_mode = Animation.LOOP_LINEAR
+	
+	# Scale property track
+	var scale_track = animation.add_track(Animation.TYPE_VALUE)
+	animation.track_set_path(scale_track, ".:scale")
+	animation.track_insert_key(scale_track, 0.0, Vector2(1.05, 1.05))
+	animation.track_insert_key(scale_track, 0.5, Vector2(1.1, 1.1))
+	animation.track_insert_key(scale_track, 1.0, Vector2(1.05, 1.05))
+	
+	anim_player.add_animation("pulse", animation)
+	anim_player.play("pulse")
+
+func _start_shake_animation() -> void:
+	# Create animation player for shake effect
+	var anim_player = AnimationPlayer.new()
+	anim_player.name = "StateAnimationPlayer"
+	
+	# Remove existing animation player if present
+	var existing_player = get_node_or_null("StateAnimationPlayer")
+	if existing_player:
+		remove_child(existing_player)
+		existing_player.queue_free()
+	
+	add_child(anim_player)
+	
+	# Create shake animation
+	var animation = Animation.new()
+	animation.name = "shake"
+	animation.length = 0.5
+	animation.loop_mode = Animation.LOOP_LINEAR
+	
+	# Position property track
+	var position_track = animation.add_track(Animation.TYPE_VALUE)
+	animation.track_set_path(position_track, ".:position_offset")
+	animation.track_insert_key(position_track, 0.0, position_offset)
+	animation.track_insert_key(position_track, 0.1, position_offset + Vector2(2, 0))
+	animation.track_insert_key(position_track, 0.2, position_offset + Vector2(-2, 0))
+	animation.track_insert_key(position_track, 0.3, position_offset + Vector2(0, 2))
+	animation.track_insert_key(position_track, 0.4, position_offset + Vector2(0, -2))
+	animation.track_insert_key(position_track, 0.5, position_offset)
+	
+	anim_player.add_animation("shake", animation)
+	anim_player.play("shake")
+
+func _stop_animations() -> void:
+	var anim_player = get_node_or_null("StateAnimationPlayer")
+	if anim_player:
+		anim_player.stop()
+
+# Update parameter value
+func set_parameter(parameter_name: String, value) -> void:
+	action_parameters[parameter_name] = value
+	
+	# Update editor if it exists
+	if property_editors.has(parameter_name):
+		var editor = property_editors[parameter_name]
+		editor.set_value(value)
+	
+	emit_signal("parameter_changed", self, parameter_name, value)
+
+# Get parameter value
+func get_parameter(parameter_name: String):
+	return action_parameters.get(parameter_name, null)
+
+# Handle node dragging
+func _on_node_dragged(from: Vector2, to: Vector2) -> void:
+	# Update position
+	position_offset = to
+
+# Handle node selection
+func _on_node_selected() -> void:
+	emit_signal("node_selected2", self)
+
+
+# Clear parameter fields
+func _clear_parameter_fields() -> void:
+	# Remove existing editors
+	for param_name in property_editors:
+		var editor = property_editors[param_name]
+		if editor.get_parent() == self:
+			remove_child(editor)
+			editor.queue_free()
+	
+	property_editors.clear()

addons/cutscene_editor/editor/nodes/DialogueActionNode.gd

@@ -0,0 +1,68 @@
+@tool
+class_name DialogueActionNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for DialogueAction
+
+func _init() -> void:
+	node_type = "dialogue"
+	node_id = "dialogue_" + str(randi())
+	title = "Dialogue"
+	modulate = Color(1.0, 1.0, 0.5)  # Yellow
+	resizable=true
+	# One input and one output connection
+	var slot = 0
+	set_slot(slot, true, 0, Color(0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Initialize default parameters
+	action_parameters["character"] = ""
+	action_parameters["text"] = ""
+	action_parameters["duration"] = 0.0
+
+func _setup_parameter_fields() -> void:
+	# Character field
+	var x = VBoxContainer.new()
+	add_child(x)
+	var char_label = Label.new()
+	char_label.text = "Character:"
+	char_label.hide()
+	x.add_child(char_label)
+	
+	var char_field = LineEdit.new()
+	char_field.text = action_parameters["character"]
+	char_field.connect("text_changed", _on_character_changed)
+	x.add_child(char_field)
+	
+	# Text field
+	var text_label = Label.new()
+	text_label.text = "Text:"
+	x.add_child(text_label)
+	
+	var text_field = TextEdit.new()
+	text_field.text = action_parameters["text"]
+	text_field.size_flags_vertical = Control.SIZE_EXPAND_FILL
+	text_field.connect("text_changed", _on_text_changed)
+	x.add_child(text_field)
+	
+	# Duration field
+	var duration_label = Label.new()
+	duration_label.text = "Duration:"
+	x.add_child(duration_label)
+	
+	var duration_field = LineEdit.new()
+	duration_field.text = str(action_parameters["duration"])
+	duration_field.connect("text_changed", _on_duration_changed)
+	x.add_child(duration_field)
+
+func _on_character_changed(new_text: String) -> void:
+	set_parameter("character", new_text)
+
+func _on_text_changed() -> void:
+	var text_edit = get_child(get_child_count() - 2)  # TextEdit is second to last child
+	set_parameter("text", text_edit.text)
+
+func _on_duration_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 0.0
+	set_parameter("duration", value)

addons/cutscene_editor/editor/nodes/EntryNode.gd

@@ -0,0 +1,20 @@
+@tool
+class_name EntryNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Entry point for the cutscene
+
+func _init() -> void:
+	node_type = "entry"
+	node_id = "entry_" + str(randi())
+	title = "Start"
+	modulate = Color(0.5, 1.0, 0.5)  # Light green
+	
+	# Entry node has no input connections
+	# Add one output connection point
+	var output_slot = 0
+	set_slot(output_slot, false, 0, Color(0, 0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Entry node has no parameter fields

addons/cutscene_editor/editor/nodes/ExitNode.gd

@@ -0,0 +1,20 @@
+@tool
+class_name ExitNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Exit point for the cutscene
+
+func _init() -> void:
+	node_type = "exit"
+	node_id = "exit_" + str(randi())
+	title = "End"
+	modulate = Color(1.0, 0.5, 0.5)  # Light red
+	
+	# Exit node has one input connection
+	# No output connections
+	var input_slot = 0
+	set_slot(input_slot, true, 0, Color(0, 0, 0), false, 0, Color(0, 0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Exit node has no parameter fields

addons/cutscene_editor/editor/nodes/MoveActionNode.gd

@@ -0,0 +1,88 @@
+@tool
+class_name MoveActionNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for MoveAction
+
+func _init() -> void:
+	node_type = "move"
+	node_id = "move_" + str(randi())
+	title = "Move"
+	modulate = Color(0.4, 0.6, 1.0)  # Blue
+	
+	# One input and one output connection
+	var slot = 0
+	set_slot(slot, true, 0, Color(0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Initialize default parameters
+	action_parameters["character"] = ""
+	action_parameters["target_x"] = 0.0
+	action_parameters["target_y"] = 0.0
+	action_parameters["speed"] = 100.0
+
+func _setup_parameter_fields() -> void:
+	# Character field
+	var char_label = Label.new()
+	char_label.text = "Character:"
+	add_child(char_label)
+	
+	var char_field = LineEdit.new()
+	char_field.text = action_parameters["character"]
+	char_field.connect("text_changed", _on_character_changed)
+	add_child(char_field)
+	
+	# Target position fields
+	var pos_label = Label.new()
+	pos_label.text = "Target Position:"
+	add_child(pos_label)
+	
+	var pos_container = HBoxContainer.new()
+	
+	var x_label = Label.new()
+	x_label.text = "X:"
+	pos_container.add_child(x_label)
+	
+	var x_field = LineEdit.new()
+	x_field.text = str(action_parameters["target_x"])
+	x_field.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	x_field.connect("text_changed", _on_target_x_changed)
+	pos_container.add_child(x_field)
+	
+	var y_label = Label.new()
+	y_label.text = "Y:"
+	pos_container.add_child(y_label)
+	
+	var y_field = LineEdit.new()
+	y_field.text = str(action_parameters["target_y"])
+	y_field.size_flags_horizontal = Control.SIZE_EXPAND_FILL
+	y_field.connect("text_changed", _on_target_y_changed)
+	pos_container.add_child(y_field)
+	
+	add_child(pos_container)
+	
+	# Speed field
+	var speed_label = Label.new()
+	speed_label.text = "Speed:"
+	add_child(speed_label)
+	
+	var speed_field = LineEdit.new()
+	speed_field.text = str(action_parameters["speed"])
+	speed_field.connect("text_changed", _on_speed_changed)
+	add_child(speed_field)
+
+func _on_character_changed(new_text: String) -> void:
+	set_parameter("character", new_text)
+
+func _on_target_x_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 0.0
+	set_parameter("target_x", value)
+
+func _on_target_y_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 0.0
+	set_parameter("target_y", value)
+
+func _on_speed_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 100.0
+	set_parameter("speed", value)

addons/cutscene_editor/editor/nodes/ParallelGroupNode.gd

@@ -0,0 +1,126 @@
+@tool
+class_name ParallelGroupNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for grouping parallel actions
+
+# Special properties for parallel groups
+var input_connections: int = 3  # Number of input connection points
+var child_nodes: Array = []     # Child nodes contained within this group
+var is_container: bool = true   # Flag to indicate this is a container node
+
+# Visual properties
+var container_rect: PanelContainer  # Visual container for child nodes
+
+func _init() -> void:
+	node_type = "parallel"
+	node_id = "parallel_" + str(randi())
+	title = "Parallel Group"
+	modulate = Color(1.0, 0.6, 0.2)  # Orange
+	
+	# Set up slots for connections
+	_setup_slots()
+	
+	# Set up container for child nodes
+	_setup_container()
+
+# Set up connection slots
+func _setup_slots() -> void:
+	# Multiple input connections for parallel actions
+	for i in range(input_connections):
+		set_slot(i, true, 0, Color(0, 0, 0), false, 0, Color(0, 0, 0, 0))
+	
+	# Single output connection for sequential continuation
+	var output_slot = input_connections
+	set_slot(output_slot, false, 0, Color(0, 0, 0, 0), true, 0, Color(0, 0, 0))
+
+# Set up visual container for child nodes
+func _setup_container() -> void:
+	# Create container panel
+	container_rect = PanelContainer.new()
+	container_rect.name = "Container"
+	container_rect.anchor_right = 1
+	container_rect.anchor_bottom = 1
+	container_rect.margin_top = 30  # Leave space for title bar
+	container_rect.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	
+	# Set container style
+	var style = StyleBoxFlat.new()
+	style.bg_color = Color(0.9, 0.9, 0.9, 0.3)
+	style.border_color = Color(0.5, 0.5, 0.5, 0.5)
+	style.border_width_left = 1
+	style.border_width_top = 1
+	style.border_width_right = 1
+	style.border_width_bottom = 1
+	container_rect.add_theme_stylebox_override("panel", style)
+	
+	add_child(container_rect)
+	
+	# Create container for child nodes
+	var child_container = VBoxContainer.new()
+	child_container.name = "ChildContainer"
+	child_container.mouse_filter = Control.MOUSE_FILTER_IGNORE
+	container_rect.add_child(child_container)
+
+# Add a child node to this parallel group
+func add_child_node(child_node: BaseGraphNode) -> void:
+	# Add to child nodes array
+	child_nodes.append(child_node)
+	
+	# Add as child in scene tree
+	if container_rect and container_rect.has_node("ChildContainer"):
+		container_rect.get_node("ChildContainer").add_child(child_node)
+	
+	# Update visual representation
+	_update_container_size()
+
+# Remove a child node from this parallel group
+func remove_child_node(child_node: BaseGraphNode) -> void:
+	# Remove from child nodes array
+	child_nodes.erase(child_node)
+	
+	# Remove from scene tree
+	if child_node.get_parent() == container_rect.get_node("ChildContainer"):
+		container_rect.get_node("ChildContainer").remove_child(child_node)
+	
+	# Update visual representation
+	_update_container_size()
+
+# Update container size based on child nodes
+func _update_container_size() -> void:
+	# Calculate required size based on child nodes
+	var required_height = 20  # Minimum height
+	
+	if container_rect and container_rect.has_node("ChildContainer"):
+		var child_container = container_rect.get_node("ChildContainer")
+		for child in child_container.get_children():
+			if child is BaseGraphNode:
+				required_height += child.size.y + 5  # Add spacing
+	
+	# Update container size
+	container_rect.custom_minimum_size.y = required_height
+
+# Handle node dragging
+func _on_node_dragged(from: Vector2, to: Vector2) -> void:
+	# Update position
+	position_offset = to
+	
+	# Update child nodes if they're positioned relative to this node
+	for child in child_nodes:
+		# Child nodes should move with the parallel group
+		pass
+
+# Add more input connections if needed
+func add_input_connection() -> void:
+	var slot_index = input_connections
+	set_slot(slot_index, true, 0, Color(0, 0, 0), false, 0, Color(0, 0, 0, 0))
+	input_connections += 1
+
+# Get the output slot index
+func get_output_slot_index() -> int:
+	return input_connections
+
+# Check if a node can be added as a child
+func can_add_child_node(node: BaseGraphNode) -> bool:
+	# Can't add entry, exit, or other parallel groups as children
+	return node.node_type != "entry" and node.node_type != "exit" and node.node_type != "parallel"

addons/cutscene_editor/editor/nodes/TurnActionNode.gd

@@ -0,0 +1,63 @@
+@tool
+class_name TurnActionNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for TurnAction
+
+func _init() -> void:
+	node_type = "turn"
+	node_id = "turn_" + str(randi())
+	title = "Turn"
+	modulate = Color(0.5, 1.0, 0.5)  # Green
+	
+	# One input and one output connection
+	var slot = 0
+	set_slot(slot, true, 0, Color(0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Initialize default parameters
+	action_parameters["character"] = ""
+	action_parameters["target"] = ""
+	action_parameters["turn_speed"] = 2.0
+
+func _setup_parameter_fields() -> void:
+	# Character field
+	var char_label = Label.new()
+	char_label.text = "Character:"
+	add_child(char_label)
+	
+	var char_field = LineEdit.new()
+	char_field.text = action_parameters["character"]
+	char_field.connect("text_changed", _on_character_changed)
+	add_child(char_field)
+	
+	# Target field
+	var target_label = Label.new()
+	target_label.text = "Target:"
+	add_child(target_label)
+	
+	var target_field = LineEdit.new()
+	target_field.text = action_parameters["target"]
+	target_field.connect("text_changed", _on_target_changed)
+	add_child(target_field)
+	
+	# Turn speed field
+	var speed_label = Label.new()
+	speed_label.text = "Turn Speed:"
+	add_child(speed_label)
+	
+	var speed_field = LineEdit.new()
+	speed_field.text = str(action_parameters["turn_speed"])
+	speed_field.connect("text_changed", _on_turn_speed_changed)
+	add_child(speed_field)
+
+func _on_character_changed(new_text: String) -> void:
+	set_parameter("character", new_text)
+
+func _on_target_changed(new_text: String) -> void:
+	set_parameter("target", new_text)
+
+func _on_turn_speed_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 2.0
+	set_parameter("turn_speed", value)

addons/cutscene_editor/editor/nodes/WaitActionNode.gd

@@ -0,0 +1,35 @@
+@tool
+class_name WaitActionNode
+extends "res://addons/cutscene_editor/editor/nodes/BaseGraphNode.gd"
+
+# Node for WaitAction
+
+func _init() -> void:
+	node_type = "wait"
+	node_id = "wait_" + str(randi())
+	title = "Wait"
+	modulate = Color(0.7, 0.7, 0.7)  # Gray
+	
+	# One input and one output connection
+	var slot = 0
+	set_slot(slot, true, 0, Color(0, 0, 0), true, 0, Color(0, 0, 0))
+
+func _ready() -> void:
+	super._ready()
+	# Initialize default parameters
+	action_parameters["duration"] = 1.0
+
+func _setup_parameter_fields() -> void:
+	# Duration field
+	var duration_label = Label.new()
+	duration_label.text = "Duration:"
+	add_child(duration_label)
+	
+	var duration_field = LineEdit.new()
+	duration_field.text = str(action_parameters["duration"])
+	duration_field.connect("text_changed", _on_duration_changed)
+	add_child(duration_field)
+
+func _on_duration_changed(new_text: String) -> void:
+	var value = float(new_text) if new_text.is_valid_float() else 1.0
+	set_parameter("duration", value)

addons/cutscene_editor/editor/resources/CutsceneResource.gd

@@ -0,0 +1,121 @@
+@tool
+class_name CutsceneResource
+extends Resource
+
+# Resource for storing cutscene data
+
+# Properties
+@export var nodes: Array = []          # List of node data
+@export var connections: Array = []    # List of connection data
+@export var parallel_connections: Array = []  # Logical connections for parallel groups
+@export var metadata: Dictionary = {}  # Additional metadata
+
+# Initialize the resource
+func _init() -> void:
+	nodes = []
+	connections = []
+	parallel_connections = []
+	metadata = {
+		"version": "1.0",
+		"created": Time.get_unix_time_from_system(),
+		"modified": Time.get_unix_time_from_system()
+	}
+
+# Add a node to the cutscene
+func add_node(node_data: Dictionary) -> void:
+	nodes.append(node_data)
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Remove a node from the cutscene
+func remove_node(node_name: String) -> void:
+	# Remove the node
+	for i in range(nodes.size()):
+		if nodes[i].has("name") and nodes[i]["name"] == node_name:
+			nodes.remove_at(i)
+			break
+	
+	# Remove any connections to/from this node
+	var i = 0
+	while i < connections.size():
+		var conn = connections[i]
+		if conn["from_node"] == node_name or conn["to_node"] == node_name:
+			connections.remove_at(i)
+		else:
+			i += 1
+	
+	# Remove any parallel connections to/from this node
+	i = 0
+	while i < parallel_connections.size():
+		var conn = parallel_connections[i]
+		if conn["from_node"] == node_name or conn["to_node"] == node_name:
+			parallel_connections.remove_at(i)
+		else:
+			i += 1
+	
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Add a connection to the cutscene
+func add_connection(connection_data: Dictionary) -> void:
+	connections.append(connection_data)
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Remove a connection from the cutscene
+func remove_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	for i in range(connections.size()):
+		var conn = connections[i]
+		if (conn["from_node"] == from_node and conn["from_port"] == from_port and
+			conn["to_node"] == to_node and conn["to_port"] == to_port):
+			connections.remove_at(i)
+			break
+	
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Add a parallel connection to the cutscene
+func add_parallel_connection(connection_data: Dictionary) -> void:
+	parallel_connections.append(connection_data)
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Remove a parallel connection from the cutscene
+func remove_parallel_connection(from_node: String, from_port: int, to_node: String, to_port: int) -> void:
+	for i in range(parallel_connections.size()):
+		var conn = parallel_connections[i]
+		if (conn["from_node"] == from_node and conn["from_port"] == from_port and
+			conn["to_node"] == to_node and conn["to_port"] == to_port):
+			parallel_connections.remove_at(i)
+			break
+	
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Get node by name
+func get_node_by_name(node_name: String) -> Dictionary:
+	for node in nodes:
+		if node.has("name") and node["name"] == node_name:
+			return node
+	return {}
+
+# Get all connections for a node
+func get_connections_for_node(node_name: String) -> Array:
+	var node_connections = []
+	for conn in connections:
+		if conn["from_node"] == node_name or conn["to_node"] == node_name:
+			node_connections.append(conn)
+	return node_connections
+
+# Get all parallel connections for a node
+func get_parallel_connections_for_node(node_name: String) -> Array:
+	var node_connections = []
+	for conn in parallel_connections:
+		if conn["from_node"] == node_name or conn["to_node"] == node_name:
+			node_connections.append(conn)
+	return node_connections
+
+# Clear all data
+func clear() -> void:
+	nodes.clear()
+	connections.clear()
+	parallel_connections.clear()
+	metadata["modified"] = Time.get_unix_time_from_system()
+
+# Update metadata
+func update_metadata() -> void:
+	metadata["modified"] = Time.get_unix_time_from_system()