gdharness 1.2.30 → 1.2.32

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -3,8 +3,11 @@ extends Node
 
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
+const FileReads = preload("../file_reads.gd")
 const Read = preload("../reading.gd")
+const Placing = preload("scene_placing.gd")
 const PropertyValues = preload("../property_values.gd")
+const ResourceTools = preload("resource_tools.gd")
 const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
@@ -101,8 +104,8 @@ func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
 		return "%s is not in the scene as it would be saved." % at
 	for key: Variant in names:
 		var property: String = str(key)
-		var loaded: Variant = copy.get(property)
-		if not scene.kept(saved, loaded, node.get(property)):
+		var loaded: Variant = _properties.read_at(copy, property)
+		if not scene.kept(saved, loaded, _properties.read_at(node, property)):
 			return (
 				(
 					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
@@ -113,81 +116,6 @@ func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
 	return ""
 
 
-## Owns [param node] and the nodes under it to [param root], except those an instanced scene
-## inside it owns: giving those to the root made the pack write the instance's own nodes into this
-## scene as overrides.
-func _copy(source: Node, root: Node, copies: Dictionary) -> Node:
-	var copy: Node = null
-	if not source.scene_file_path.is_empty():
-		# An instanced scene made again from its file, so the copy is an instance too. Node.duplicate
-		# makes a plain node of the instance's class, and the pack saved it with every property of the
-		# instance's root frozen into this scene.
-		var packed: PackedScene = ResourceLoader.load(source.scene_file_path, "PackedScene") as PackedScene
-		if packed == null:
-			return null
-		copy = packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
-		for declared: Dictionary in source.get_property_list():
-			if not (Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
-				continue
-			var property: String = str(declared.get("name", ""))
-			var value: Variant = source.get(property)
-			if not PropertyValues.same(copy.get(property), value):
-				copy.set(property, value)
-		for group: StringName in source.get_groups():
-			if not copy.is_in_group(group):
-				copy.add_to_group(group, true)
-	else:
-		copy = source.duplicate(Node.DUPLICATE_GROUPS | Node.DUPLICATE_SCRIPTS)
-		for child: Node in copy.get_children():
-			copy.remove_child(child)
-			child.free()
-	copy.name = source.name
-	copies[source] = copy
-	# Only what this scene owns: an instance's own nodes come with the instance.
-	for child: Node in source.get_children():
-		if child.owner == root:
-			var copied: Node = _copy(child, root, copies)
-			if copied == null:
-				return null
-			copy.add_child(copied)
-	return copy
-
-
-## Gives each copy in [param copies] the persistent connections its source has, to the copy of the
-## target when the target was copied too. A connection an instance makes inside itself is skipped:
-## the instance made again from its file already has it.
-func _reconnect(copies: Dictionary, top: Node) -> void:
-	for key: Variant in copies:
-		var source: Node = key
-		var copy: Node = copies[key]
-		for info: Dictionary in source.get_signal_list():
-			var signal_name: String = str(info.get("name", ""))
-			for conn: Dictionary in source.get_signal_connection_list(signal_name):
-				var flags: int = Read.as_int(conn.get("flags", 0))
-				var callable: Callable = conn.get("callable", Callable())
-				var target: Object = callable.get_object()
-				if not flags & Object.CONNECT_PERSIST or target == null:
-					continue
-				var to: Object = copies.get(target, target)
-				if to == target and target is Node and (target == top or top.is_ancestor_of(target as Node)):
-					continue
-				var copied: Callable = Callable(to, callable.get_method())
-				if (
-					not copy.is_connected(signal_name, copied)
-					and copy.connect(signal_name, copied, flags) != OK
-				):
-					push_error(
-						"gdharness: could not copy the connection %s of %s" % [signal_name, source.name]
-					)
-
-
-func _own(node: Node, root: Node) -> void:
-	node.owner = root
-	for child: Node in node.get_children():
-		if child.owner == null or child.owner == root:
-			_own(child, root)
-
-
 ## [param node]'s stored properties as a read answers them. A property holding a node is answered
 ## as the path to it: the copy read here is never in the tree, and an object description named a
 ## node that was freed when the call ended.
@@ -240,27 +168,6 @@ func _parse_properties_arg(raw_properties: Variant) -> Dictionary:
 	return {}
 
 
-func _build_node_tree(
-	node: Node, include_properties: bool, depth: int, current_depth: int, node_path: String
-) -> Dictionary:
-	var children: Array[Dictionary] = []
-	var data: Dictionary = {
-		"name": str(node.name), "type": node.get_class(), "path": node_path, "children": children
-	}
-
-	if include_properties:
-		data["properties"] = _properties_of(node, true, {})
-
-	if depth >= 0 and current_depth >= depth:
-		return data
-
-	for child: Node in node.get_children():
-		var child_path: String = str(child.name) if node_path == "." else node_path + "/" + str(child.name)
-		children.append(_build_node_tree(child, include_properties, depth, current_depth + 1, child_path))
-
-	return data
-
-
 func _collect_nodes_recursive(node: Node, path: String, out_nodes: Array) -> void:
 	out_nodes.append({"path": path, "node": node})
 	for child: Node in node.get_children():
@@ -349,31 +256,29 @@ func list_scene_nodes(args: Dictionary) -> Dictionary:
 	var depth: int = Read.as_int(args.get("depth", -1), -1)
 	var include_properties: bool = Read.as_bool(args.get("includeProperties", false))
 
-	var opened: Array = _open(scene_path, false)
-	var scene: SceneFile = opened[0]
-	var refused: Dictionary = opened[1]
-	if not refused.is_empty():
-		return refused
-
-	var tree: Dictionary = _build_node_tree(scene.root, include_properties, depth, 0, ".")
-	scene.close()
-	return {"ok": true, "tree": tree, "unsavedInEditor": SceneFile.unsaved(scene_path)}
+	# Read as a headless engine reads it with no editor connected, so the answer does not depend on
+	# whether one is.
+	var read: Dictionary = FileReads.scene_tree(scene_path, depth, include_properties)
+	if read.get("ok", false):
+		read["unsavedInEditor"] = SceneFile.unsaved(scene_path)
+	return read
 
 
 func add_node(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
 	var node_type: String = str(args.get("nodeType", ""))
+	var instance_path: String = str(args.get("instancePath", ""))
 	var node_name: String = str(args.get("nodeName", ""))
 	var parent_node_path: String = str(args.get("parentNodePath", "."))
 	var properties: Dictionary = _parse_properties_arg(args.get("properties", {}))
 
-	if node_type.is_empty() or node_name.is_empty():
-		return {"ok": false, "error": "Missing nodeType or nodeName"}
-	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
-		return {"ok": false, "error": "nodeType must be a node class, and %s is not one." % node_type}
-	if not ClassDB.can_instantiate(node_type):
-		return {"ok": false, "error": "%s cannot be instantiated." % node_type}
+	if node_name.is_empty():
+		return {"ok": false, "error": "Missing nodeName"}
+	var making: Array = Placing.what_to_add(node_type, instance_path, scene_path)
+	var packed: PackedScene = making[0]
+	if not str(making[1]).is_empty():
+		return {"ok": false, "error": making[1]}
 
 	var opened: Array = _open(scene_path, true)
 	var scene: SceneFile = opened[0]
@@ -391,24 +296,39 @@ func add_node(args: Dictionary) -> Dictionary:
 	var unusable: String = scene.unusable_name(parent, node_name)
 	if not unusable.is_empty():
 		return scene.refuse(unusable)
+	var place: Variant = args.get("index")
+	var unplaceable: String = Placing.unplaceable(parent, null, place)
+	if not unplaceable.is_empty():
+		return scene.refuse(unplaceable)
 
 	# In the tree before its properties, so a property holding a node can find it by path.
-	var new_node: Node = ClassDB.instantiate(node_type)
+	var new_node: Node = Placing.made(packed, node_type)
 	new_node.name = node_name
 	parent.add_child(new_node)
-	_own(new_node, root)
+	Placing.place(new_node, place)
+	Placing.own(new_node, root)
 	var refused_property: String = _properties.write_all(new_node, properties)
 	if not refused_property.is_empty():
 		return scene.refuse(refused_property)
 
 	var new_path: String = scene.path_of(new_node)
+	# Read before the write, which frees the scene it was added to.
+	var answer: Dictionary = {
+		"ok": true,
+		"nodeName": node_name,
+		"nodeType": new_node.get_class(),
+		"nodePath": new_path,
+		"index": new_node.get_index(),
+	}
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String: return _kept(scene, saved, new_node, properties.keys())
 	)
 	if not written.is_empty():
 		return written
 
-	return {"ok": true, "nodeName": node_name, "nodeType": node_type, "nodePath": new_path}
+	if packed != null:
+		answer["instanceOf"] = instance_path
+	return answer
 
 
 func delete_node(args: Dictionary) -> Dictionary:
@@ -487,14 +407,14 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 		return scene.refuse(unusable)
 
 	var copies: Dictionary = {}
-	var duplicated_node: Node = _copy(source, root, copies)
+	var duplicated_node: Node = Placing.copied(source, root, copies)
 	if not duplicated_node:
 		return scene.refuse("Failed to duplicate node: " + node_path)
 
 	duplicated_node.name = new_name
 	target_parent.add_child(duplicated_node)
-	_own(duplicated_node, root)
-	_reconnect(copies, source)
+	Placing.own(duplicated_node, root)
+	Placing.reconnect(copies, source)
 
 	var new_path: String = scene.path_of(duplicated_node)
 	var written: Dictionary = scene.write(
@@ -548,25 +468,40 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var unusable: String = scene.unusable_name(new_parent, str(node.name), node)
 	if not unusable.is_empty():
 		return scene.refuse(unusable)
+	var place: Variant = args.get("index")
+	var unplaceable: String = Placing.unplaceable(new_parent, node, place)
+	if not unplaceable.is_empty():
+		return scene.refuse(unplaceable)
 
 	var old_path: String = scene.path_of(node)
 	node.get_parent().remove_child(node)
 	new_parent.add_child(node)
-	_own(node, root)
+	Placing.place(node, place)
+	Placing.own(node, root)
 
 	var new_path: String = scene.path_of(node)
+	var index: int = node.get_index()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
-			if saved.get_node_or_null(new_path) == null:
+			var copy: Node = saved.get_node_or_null(new_path)
+			if copy == null:
 				return "%s would not be in the scene when it loads." % new_path
 			if old_path != new_path and saved.get_node_or_null(old_path) != null:
 				return "%s would still be in the scene as well when it loads." % old_path
+			if copy.get_index() != index:
+				return "%s would load at index %d, not %d." % [new_path, copy.get_index(), index]
 			return ""
 	)
 	if not written.is_empty():
 		return written
 
-	return {"ok": true, "nodePath": old_path, "newParentPath": new_parent_path, "newNodePath": new_path}
+	return {
+		"ok": true,
+		"nodePath": old_path,
+		"newParentPath": new_parent_path,
+		"newNodePath": new_path,
+		"index": index,
+	}
 
 
 func set_node_properties(args: Dictionary) -> Dictionary:
@@ -601,7 +536,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 
 	var held: Dictionary = {}
 	for key: Variant in properties:
-		held[str(key)] = _readable(node, node.get(str(key)))
+		held[str(key)] = _readable(node, _properties.read_at(node, str(key)))
 	var new_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String: return _kept(scene, saved, node, properties.keys())
@@ -633,6 +568,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# variable read as changed; and a value this scene sets back to the default was hidden, so the
 	# names this scene's file sets are always answered.
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
+	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
 	var answer: Dictionary = {
 		"ok": true,
@@ -640,6 +576,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 		"properties": props,
 		"unsavedInEditor": SceneFile.unsaved(scene_path)
 	}
+	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
 		answer["note"] = (
@@ -757,6 +694,10 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
 	var callable: Callable = Callable(target, method_name)
 	var method_found: bool = target.has_method(method_name)
+	var flags_before: int = -1
+	for connection: Dictionary in source.get_signal_connection_list(signal_name):
+		if connection.get("callable") == callable:
+			flags_before = Read.as_int(connection.get("flags", 0))
 	if source.is_connected(signal_name, callable):
 		source.disconnect(signal_name, callable)
 	var connect_result: Error = source.connect(signal_name, callable, flags)
@@ -776,7 +717,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"sourceNodePath": from,
 		"signalName": signal_name,
@@ -788,6 +729,14 @@ func connect_signal(args: Dictionary) -> Dictionary:
 		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
 		"methodFound": method_found
 	}
+	# A second connect of the same pair read exactly like the first, so a caller could not tell a
+	# connection made from one that was already there, and a list showing one where two were made
+	# looked like a lost write.
+	if flags_before >= 0:
+		answer["alreadyConnected"] = true
+		if flags_before != Read.as_int(saved_flags[0]):
+			answer["flagsBefore"] = _flag_names(flags_before)
+	return answer
 
 
 ## The two ends of a connection in [param scene], as [source, target], or [null, why not].

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -49,6 +49,10 @@ const PROFILER_PROBE_CALLS: int = 10000
 ## on every 2048th call and only counts the others.
 const POLLS_PER_READ: int = 2048
 
+## The most frames a close waits for its answer to leave: a client that stopped reading would
+## otherwise hold the close for ever, and the server is past caring about the answer by then.
+const CLOSE_AFTER_FRAMES: int = 30
+
 ## Set in a game's environment by whatever starts it to be profiled from its start: the server for
 ## a run it spawns, the editor for a play. Kept in step with `PROFILE_FROM_START` in the server.
 const PROFILE_FROM_START: String = "GDHARNESS_PROFILE_FROM_START"
@@ -118,6 +122,8 @@ var _commands: Dictionary = {}
 var _loaded_version: String = _read_marker(VERSION_MARKER)
 var _loaded_digest: String = _read_marker(DIGEST_MARKER)
 var _profile_received: bool = false
+var _close_asked: bool = false
+var _close_frames: int = 0
 var _profiler_calibrated: bool = false
 
 
@@ -140,6 +146,7 @@ func _init() -> void:
 		"inject_text": _typing.inject_text,
 		"inject_mouse_click": _input.inject_mouse_click,
 		"inject_mouse_motion": _input.inject_mouse_motion,
+		"inject_mouse_drag": _input.inject_mouse_drag,
 		"inject_joypad_button": _pad.inject_joypad_button,
 		"inject_joypad_motion": _pad.inject_joypad_motion,
 		"click": _input.click,
@@ -148,6 +155,7 @@ func _init() -> void:
 		"wait_signal": _waits.wait_signal,
 		"wait_until": _waits.wait_until,
 		"send_profile": _send_profile_now,
+		"close_game": _close_game,
 	}
 	_wait_for_the_profiler()
 
@@ -341,6 +349,14 @@ func _process(_delta: float) -> void:
 		var _had_pending: bool = _pending.erase(client)
 		var _had_outgoing: bool = _outgoing.erase(client)
 
+	# After the answer to the close has gone out: the close request reaches this node too, which then
+	# drops its clients and whatever they were still owed.
+	if _close_asked:
+		_close_frames += 1
+		if _close_frames >= CLOSE_AFTER_FRAMES or _outgoing.values().all(_is_empty):
+			_close_asked = false
+			_deliver_close()
+
 
 ## Hands the socket as much of what it is owed as it will take, and says whether it is still worth
 ## talking to. Reading comes first in the frame, so a client that asked and left is noticed here
@@ -578,6 +594,29 @@ func _ping(_params: Dictionary) -> Dictionary:
 	return {"type": "pong", "timestamp": Time.get_unix_time_from_system()}
 
 
+## The game asked to close, as a player's close asks it: answered at once and delivered once the
+## answer has gone out. `acceptsQuit` says whether the tree quits on the request by itself; a game
+## that turned that off decides for itself, and may ask the player first.
+func _close_game(_params: Dictionary) -> Dictionary:
+	_close_asked = true
+	_close_frames = 0
+	return {"type": "closing", "acceptsQuit": get_tree().auto_accept_quit}
+
+
+## What a player's close does: the close request reaches every node, and then the root window says
+## it was asked to close, which the tree answers by quitting when it accepts quits. So the game's own
+## close runs, a crash guard's included, where a stop that ended the process ran none of it.
+func _deliver_close() -> void:
+	var root: Window = get_tree().root
+	root.propagate_notification(NOTIFICATION_WM_CLOSE_REQUEST)
+	root.close_requested.emit()
+
+
+static func _is_empty(owed: Variant) -> bool:
+	var bytes: PackedByteArray = owed
+	return bytes.is_empty()
+
+
 ## One JSON object and a newline, queued for [method _drain] rather than written here.
 ##
 ## Raw bytes rather than put_utf8_string, which would prefix them with a length the other side is