gdharness 1.2.31 → 1.2.32

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

@@ -0,0 +1,178 @@
+@tool
+extends RefCounted
+
+## What a new node in a scene is made or copied from, what the scene owns of it, and where among its
+## siblings a node may go.
+
+const Read = preload("../reading.gd")
+const PropertyValues = preload("../property_values.gd")
+
+
+## The scene to instance for an add, or null for a node of a class, beside why neither can be made
+## ("" when one can), as [PackedScene, String].
+static func what_to_add(node_type: String, instance_path: String, scene_path: String) -> Array:
+	if node_type.is_empty() == instance_path.is_empty():
+		return [
+			null,
+			"add takes nodeType for a node of a class, or instancePath for a scene, and one of them only."
+		]
+	if not instance_path.is_empty():
+		var cycle: String = _instancing_cycle(scene_path, instance_path)
+		if not cycle.is_empty():
+			return [null, cycle]
+		if not ResourceLoader.exists(instance_path, "PackedScene"):
+			return [null, "No scene at %s to instance." % instance_path]
+		var packed: PackedScene = ResourceLoader.load(instance_path, "PackedScene") as PackedScene
+		if packed == null or not packed.can_instantiate():
+			return [null, "%s does not load as a scene that can be instanced." % instance_path]
+		return [packed, ""]
+	if node_type.begins_with("res://") or node_type.get_extension() in ["tscn", "scn"]:
+		return [
+			null,
+			(
+				"nodeType must be a node class, and %s is a scene: pass it as instancePath to instance it."
+				% node_type
+			)
+		]
+	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
+		return [null, "nodeType must be a node class, and %s is not one." % node_type]
+	if not ClassDB.can_instantiate(node_type):
+		return [null, "%s cannot be instantiated." % node_type]
+	return [null, ""]
+
+
+## A new node of [param node_type], or an instance of [param packed] when there is one. The instance
+## is made in the editor's edit state, so the pack writes it as an instance of its file, and owning
+## its root leaves its own nodes to the instanced scene.
+static func made(packed: PackedScene, node_type: String) -> Node:
+	if packed != null:
+		return packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
+	var node: Object = ClassDB.instantiate(node_type)
+	return node as Node
+
+
+## A copy of [param source] and the nodes under it that [param root] owns, each copy recorded in
+## [param copies] against its source, or null when an instance in it no longer loads.
+static func copied(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 under: Node = copied(child, root, copies)
+			if under == null:
+				return null
+			copy.add_child(under)
+	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.
+static 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 aimed: Callable = Callable(to, callable.get_method())
+				if (
+					not copy.is_connected(signal_name, aimed)
+					and copy.connect(signal_name, aimed, flags) != OK
+				):
+					push_error(
+						"gdharness: could not copy the connection %s of %s" % [signal_name, source.name]
+					)
+
+
+## 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.
+static 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)
+
+
+## Why [param asked] is not a position [param node] can take among [param parent]'s children, or ""
+## when it is, or when none was asked for. [param node] is null for a node not yet added.
+static func unplaceable(parent: Node, node: Node, asked: Variant) -> String:
+	if asked == null:
+		return ""
+	var others: int = parent.get_child_count() - (1 if node != null and node.get_parent() == parent else 0)
+	var at: int = Read.as_int(asked, -1)
+	if at < 0 or at > others:
+		return (
+			"index %s is not a place among the %d other children of %s: give 0 to %d, 0 for first."
+			% [
+				str(at) if asked is int or asked is float else JSON.stringify(asked),
+				others,
+				parent.name,
+				others
+			]
+		)
+	return ""
+
+
+## Moves [param node] to [param asked] among its siblings, when a place was asked for.
+static func place(node: Node, asked: Variant) -> void:
+	if asked != null:
+		node.get_parent().move_child(node, Read.as_int(asked))
+
+
+## Why [param instanced] cannot be instanced into [param scene_path], or "" when it can: a scene
+## inside itself, directly or through the scenes it instances, which Godot's own dialog refuses and
+## which never finishes loading.
+static func _instancing_cycle(scene_path: String, instanced: String) -> String:
+	var seen: Dictionary[String, bool] = {}
+	var waiting: Array[String] = [instanced]
+	while not waiting.is_empty():
+		var at: String = waiting.pop_back()
+		if at == scene_path:
+			return (
+				"%s cannot be instanced into %s: it %s, so the scene would hold itself."
+				% [instanced, scene_path, "is that scene" if at == instanced else "instances it"]
+			)
+		if seen.has(at):
+			continue
+		seen[at] = true
+		for dependency: String in ResourceLoader.get_dependencies(at):
+			# Slices joined by "::", the UID, the type and the path, some of them empty.
+			for part: String in dependency.split("::"):
+				if part.begins_with("res://") and part.get_extension() in ["tscn", "scn"]:
+					waiting.append(part)
+	return ""

package/build/godot/addons/gdharness_editor/tools/scene_placing.gd.uid

@@ -0,0 +1 @@
+uid://bgnjhedq2qj3t

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

@@ -3,7 +3,9 @@ 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")
@@ -114,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.
@@ -241,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():
@@ -350,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]
@@ -392,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:
@@ -488,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(
@@ -549,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:

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