gdharness 1.3.2 → 1.3.4

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

@@ -0,0 +1,363 @@
+@tool
+extends Node
+
+## Signal connections in a scene file, made, removed and listed on a copy of the file as the other
+## scene tools edit one.
+
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+
+## What every emission meets when a connection cannot call its method.
+const FAILS: String = ", so every emission fails to call it."
+
+
+func connect_signal(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var source_node_path: String = str(args.get("sourceNodePath", ""))
+	var signal_name: String = str(args.get("signalName", ""))
+	var target_node_path: String = str(args.get("targetNodePath", ""))
+	var method_name: String = str(args.get("methodName", ""))
+	# A connection without CONNECT_PERSIST is a runtime one, and PackedScene.pack drops those on
+	# the way out: without this the scene saves unchanged and this answers success over nothing.
+	var flags: int = GdhRead.as_int(args.get("flags", 0)) | Object.CONNECT_PERSIST
+
+	if (
+		source_node_path.is_empty()
+		or signal_name.is_empty()
+		or target_node_path.is_empty()
+		or method_name.is_empty()
+	):
+		return {"ok": false, "error": "Missing required signal connection arguments"}
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, true)
+	if not refused.is_empty():
+		return refused
+
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
+
+	# Reconnected rather than left alone when the flags differ, so the connection saved is the one
+	# 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 misfit: String = _misfit(source, signal_name, callable, flags)
+	var flags_before: int = -1
+	for connection: Dictionary in source.get_signal_connection_list(signal_name):
+		if connection.get("callable") == callable:
+			flags_before = GdhRead.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)
+	if connect_result != OK:
+		return scene.refuse("Failed to connect signal: " + error_string(connect_result))
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	var saved_flags: Array = [-1]
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			saved_flags[0] = _connection_flags(saved, from, signal_name, to, method_name)
+			if saved_flags[0] < 0:
+				return "the connection would not be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
+
+	var answer: Dictionary = {
+		"ok": true,
+		"sourceNodePath": from,
+		"signalName": signal_name,
+		"targetNodePath": to,
+		"methodName": method_name,
+		"flags": saved_flags[0],
+		"flagNames": GdhSceneFile.flag_names(GdhRead.as_int(saved_flags[0])),
+		# Connected either way, as the editor's own dialog allows, since the method may be written
+		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
+		"methodFound": method_found
+	}
+	# Written all the same, for the reason a missing method is: the method may be changed next.
+	if method_found:
+		answer["argumentsFit"] = misfit.is_empty()
+	if not misfit.is_empty():
+		answer["misfit"] = misfit
+	# 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 != GdhRead.as_int(saved_flags[0]):
+			answer["flagsBefore"] = GdhSceneFile.flag_names(flags_before)
+	return answer
+
+
+## The two ends of a connection in [param scene], as [source, target], or [null, why not].
+func _connection_ends(
+	scene: GdhSceneFile, source_node_path: String, signal_name: String, target_node_path: String
+) -> Array:
+	var source: Node = GdhSceneFile.node_at(scene.root, source_node_path)
+	var target: Node = GdhSceneFile.node_at(scene.root, target_node_path)
+	if not source:
+		return [null, scene.not_found("Source node not found: " + source_node_path, source_node_path)]
+	if not target:
+		return [null, scene.not_found("Target node not found: " + target_node_path, target_node_path)]
+	# pack drops a connection with either end inside an instanced scene, and the answer said it was
+	# made or removed.
+	for end: Node in [source, target]:
+		var foreign: String = scene.foreign(end)
+		if not foreign.is_empty():
+			return [null, foreign]
+	if not source.has_signal(signal_name):
+		var said: String = "%s has no signal %s" % [source_node_path, signal_name]
+		var offered: String = GdhRead.offered(said, signal_name, GdhRead.signals_of(source))
+		return [null, GdhSceneFile.missing_on(source, offered)]
+	return [source, target]
+
+
+## The flags of the persistent connection from [param from]'s [param signal_name] to
+## [param method] on [param to] in the tree under [param root], or -1 when there is none.
+func _connection_flags(root: Node, from: String, signal_name: String, to: String, method: String) -> int:
+	var source: Node = root.get_node_or_null(from)
+	var target: Node = root.get_node_or_null(to)
+	if source == null or target == null or not source.has_signal(signal_name):
+		return -1
+	for conn: Dictionary in source.get_signal_connection_list(signal_name):
+		var flags: int = GdhRead.as_int(conn.get("flags", 0))
+		var callable: Callable = conn.get("callable", Callable())
+		if (
+			flags & Object.CONNECT_PERSIST
+			and callable.get_object() == target
+			and str(callable.get_method()) == method
+		):
+			return flags
+	return -1
+
+
+## Why what [param signal_name] of [param source] passes cannot reach [param callable], or "" when it
+## can or the method is not there to judge. Only what fails on every emission is named: too few or
+## too many arguments, an object passed where the method takes a value or the reverse, and an engine
+## class unrelated to the one the method takes. Anything that may convert or narrow when it runs is
+## left alone, since a warning about a connection that works is one nobody can act on.
+static func _misfit(source: Node, signal_name: String, callable: Callable, flags: int) -> String:
+	var target: Object = callable.get_object()
+	var method: String = str(callable.get_method())
+	var taken: Dictionary = {}
+	for info: Dictionary in target.get_method_list() if target != null else []:
+		if str(info.get("name", "")) == method:
+			taken = info
+			break
+	if taken.is_empty() or GdhRead.as_int(taken.get("flags", 0)) & METHOD_FLAG_VARARG:
+		return ""
+	var passed: Array[Dictionary] = []
+	for info: Dictionary in source.get_signal_list():
+		if str(info.get("name", "")) == signal_name:
+			for argument: Dictionary in info.get("args", []):
+				passed.append(argument)
+			break
+	if flags & Object.CONNECT_APPEND_SOURCE_OBJECT:
+		passed.append({"name": "source", "type": TYPE_OBJECT, "class_name": source.get_class()})
+	passed = passed.slice(0, maxi(passed.size() - callable.get_unbound_arguments_count(), 0))
+	for bound: Variant in callable.get_bound_arguments():
+		var bound_class: String = ""
+		if bound is Object:
+			var object: Object = bound
+			bound_class = object.get_class()
+		passed.append({"name": "bound", "type": typeof(bound), "class_name": bound_class})
+
+	var parameters: Array = taken.get("args", [])
+	var defaults: Array = taken.get("default_args", [])
+	var needed: int = parameters.size() - defaults.size()
+	if passed.size() < needed:
+		return "%s passes %s, and %s needs %d%s" % [signal_name, _count(passed.size()), method, needed, FAILS]
+	if passed.size() > parameters.size():
+		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
+		return "%s passes %s, and %s takes %s%s" % [signal_name, _count(passed.size()), method, most, FAILS]
+	for at: int in passed.size():
+		var given: Dictionary = passed[at]
+		var parameter: Dictionary = parameters[at]
+		if not _unrelated(given, parameter):
+			continue
+		return (
+			"%s passes argument %d as %s, and %s takes it as %s: %s%s"
+			% [
+				signal_name,
+				at + 1,
+				_type_named(given),
+				method,
+				str(parameter.get("name", "")),
+				_type_named(parameter),
+				FAILS
+			]
+		)
+	return ""
+
+
+## Whether a value declared as [param given] can never be passed as [param parameter].
+static func _unrelated(given: Dictionary, parameter: Dictionary) -> bool:
+	var given_type: int = GdhRead.as_int(given.get("type", TYPE_NIL))
+	var taken_type: int = GdhRead.as_int(parameter.get("type", TYPE_NIL))
+	if given_type == TYPE_NIL or taken_type == TYPE_NIL:
+		return false
+	if (given_type == TYPE_OBJECT) != (taken_type == TYPE_OBJECT):
+		return true
+	if given_type != TYPE_OBJECT:
+		return false
+	var given_class: String = str(given.get("class_name", ""))
+	var taken_class: String = str(parameter.get("class_name", ""))
+	# A class a script declares is not in ClassDB, and an engine class can still hold an instance of
+	# one, so only two engine classes are judged.
+	if not ClassDB.class_exists(given_class) or not ClassDB.class_exists(taken_class):
+		return false
+	return (
+		not ClassDB.is_parent_class(given_class, taken_class)
+		and not ClassDB.is_parent_class(taken_class, given_class)
+	)
+
+
+static func _type_named(declared: Dictionary) -> String:
+	var type: int = GdhRead.as_int(declared.get("type", TYPE_NIL))
+	var named: String = str(declared.get("class_name", ""))
+	if type == TYPE_OBJECT and not named.is_empty():
+		return named
+	return type_string(type)
+
+
+static func _count(arguments: int) -> String:
+	if arguments == 0:
+		return "no arguments"
+	return "1 argument" if arguments == 1 else "%d arguments" % arguments
+
+
+func disconnect_signal(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var source_node_path: String = str(args.get("sourceNodePath", ""))
+	var signal_name: String = str(args.get("signalName", ""))
+	var target_node_path: String = str(args.get("targetNodePath", ""))
+	var method_name: String = str(args.get("methodName", ""))
+
+	if (
+		source_node_path.is_empty()
+		or signal_name.is_empty()
+		or target_node_path.is_empty()
+		or method_name.is_empty()
+	):
+		return {"ok": false, "error": "Missing required signal disconnection arguments"}
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, true)
+	if not refused.is_empty():
+		return refused
+
+	var ends: Array = _connection_ends(scene, source_node_path, signal_name, target_node_path)
+	if ends[0] == null:
+		return scene.refuse(str(ends[1]))
+	var source: Node = ends[0]
+	var target: Node = ends[1]
+
+	var from: String = scene.path_of(source)
+	var to: String = scene.path_of(target)
+	# A connection that was never there saved the scene unchanged and answered as removed, so a
+	# typo in either name read as success.
+	if _connection_flags(scene.root, from, signal_name, to, method_name) < 0:
+		return scene.refuse(
+			"%s has no connection from %s.%s to %s.%s." % [scene_path, from, signal_name, to, method_name]
+		)
+	source.disconnect(signal_name, Callable(target, method_name))
+
+	var written: Dictionary = scene.write(
+		func(saved: Node) -> String:
+			if _connection_flags(saved, from, signal_name, to, method_name) >= 0:
+				return "the connection would still be in the scene when it loads."
+			return ""
+	)
+	if not written.is_empty():
+		return written
+
+	return {
+		"ok": true,
+		"removed": true,
+		"sourceNodePath": from,
+		"signalName": signal_name,
+		"targetNodePath": to,
+		"methodName": method_name
+	}
+
+
+func list_connections(args: Dictionary) -> Dictionary:
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	var filter_path: String = str(args.get("nodePath", ""))
+
+	var scene: GdhSceneFile = GdhSceneFile.new()
+	var refused: Dictionary = scene.open(scene_path, false)
+	if not refused.is_empty():
+		return refused
+
+	var root: Node = scene.root
+	var filtered: Node = null
+	if not filter_path.is_empty():
+		filtered = GdhSceneFile.node_at(root, filter_path)
+		if filtered == null:
+			return scene.refuse(scene.not_found("Node not found: " + filter_path, filter_path))
+	var nodes: Array = []
+	_collect_nodes_recursive(root, ".", nodes)
+
+	# Only persistent connections, which are the ones a scene file holds: a Container connects
+	# signals of each child to itself as the child is added, and those were answered as if the file
+	# held them. Matched on either end, since the filter is for connections involving the node.
+	var connections: Array = []
+	for entry: Dictionary in nodes:
+		var path: String = str(entry["path"])
+		var node: Node = entry["node"]
+		for signal_info: Dictionary in node.get_signal_list():
+			var signal_name: String = str(signal_info.get("name", ""))
+			if signal_name.is_empty():
+				continue
+			for conn: Dictionary in node.get_signal_connection_list(signal_name):
+				var flags: int = GdhRead.as_int(conn.get("flags", 0))
+				if not flags & Object.CONNECT_PERSIST:
+					continue
+				var callable: Callable = conn.get("callable", Callable())
+				var target_obj: Object = callable.get_object()
+				if filtered != null and node != filtered and target_obj != filtered:
+					continue
+				var target_path: String = ""
+				var editable: bool = scene.foreign(node).is_empty()
+				if target_obj is Node:
+					target_path = str(root.get_path_to(target_obj as Node))
+					editable = editable and scene.foreign(target_obj as Node).is_empty()
+				var listed: Dictionary = {
+					"sourceNodePath": path,
+					"signalName": signal_name,
+					"targetNodePath": target_path,
+					"methodName": str(callable.get_method()),
+					"flags": flags,
+					"flagNames": GdhSceneFile.flag_names(flags),
+					# False for a connection an instanced scene makes inside itself, which only that
+					# scene can change.
+					"editable": editable,
+					"methodFound": target_obj != null and target_obj.has_method(callable.get_method()),
+				}
+				var misfit: String = _misfit(node, signal_name, callable, flags)
+				if not misfit.is_empty():
+					listed["misfit"] = misfit
+				connections.append(listed)
+
+	scene.close()
+	var answer: Dictionary = {"ok": true, "connections": connections}
+	if Engine.is_editor_hint():
+		answer["unsavedInEditor"] = GdhSceneFile.unsaved(scene_path)
+	return answer
+
+
+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():
+		var child_path: String = str(child.name) if path == "." else path + "/" + str(child.name)
+		_collect_nodes_recursive(child, child_path, out_nodes)

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

@@ -0,0 +1 @@
+uid://8ktrjlekhgex

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

@@ -189,6 +189,21 @@ static func offered(said: String, word: String, names: Array) -> String:
 	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
 
 
+## [param said], the refusal for [param property], which [param target] does not declare, with the
+## names it declares nearest it when any are, as a misspelt one is usually one of them. Unlike
+## [method offered], nothing is listed when none is near, since an object declares a hundred.
+static func near_property(said: String, target: Object, property: String) -> String:
+	var headings: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
+	var names: Array[String] = []
+	for declared: Dictionary in target.get_property_list():
+		if not as_int(declared.get("usage", 0)) & headings:
+			names.append(str(declared.get("name", "")))
+	var close: PackedStringArray = nearest(property, PackedStringArray(names))
+	if close.is_empty():
+		return said
+	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+
+
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
 ## lists them from Object down, which puts a Button's pressed after thirty a Control has, and names
 ## starting with an underscore are the engine's own.

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

@@ -17,9 +17,6 @@ const GdhScreen = preload("runtime_screen.gd")
 const GdhTargets = preload("runtime_targets.gd")
 const GdhMouse = preload("runtime_mouse.gd")
 
-## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
-const TO_SMALL: int = 32
-
 ## Set, to the desktop's name, for a process gdharness started on a desktop of its own and for
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
@@ -161,10 +158,11 @@ func inject_action(params: Dictionary) -> Dictionary:
 	var frames: int = holding
 
 	_say_action(action, whole or held, strength)
+	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a click has: a listener that acts on the press and
 		# a listener that acts on the release both get their own frame to do it in.
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		_say_action(action, false, strength)
 		await _host.get_tree().process_frame
 
@@ -175,15 +173,10 @@ func inject_action(params: Dictionary) -> Dictionary:
 		"pressed": held and not whole,
 		"whole": whole,
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 	}
 
 
-## Waits out [param frames] process frames, which is how long a whole press is held down.
-func _held(frames: int) -> void:
-	for _frame: int in frames:
-		await _host.get_tree().process_frame
-
-
 func _say_action(action: String, down: bool, strength: float) -> void:
 	var event: InputEventAction = InputEventAction.new()
 	event.action = action
@@ -237,11 +230,12 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
 	# action in the map and still type nothing into a search box. Godot's keycodes for printable
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
-	event.unicode = _glyph_of(event.keycode, event.shift_pressed)
+	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
 	Input.parse_input_event(event)
+	var lasted: Variant = null
 	if whole:
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		var up: InputEventKey = event.duplicate()
 		up.pressed = false
 		Input.parse_input_event(up)
@@ -251,6 +245,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 		"type": "input_injected",
 		"input_type": "key",
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 		"keycode": event.keycode,
 		"physical_keycode": event.physical_keycode,
 		"shift": event.shift_pressed,
@@ -262,19 +257,6 @@ func inject_key(params: Dictionary) -> Dictionary:
 	}
 
 
-## The character a key produces, or nothing for a key that produces none.
-##
-## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
-## print something, so the mapping is the value itself. Letters are held as their capitals, which
-## is the one place the shift a caller asked for changes the answer rather than the key.
-func _glyph_of(keycode: Key, shifted: bool) -> int:
-	if keycode >= KEY_SPECIAL:
-		return 0
-	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
-		return keycode + TO_SMALL
-	return keycode
-
-
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
 ##
 ## The whole click by default, for the reason [method inject_action] is the whole press, and
@@ -314,12 +296,13 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	var _moved: Vector2 = _arrive(position)
 	var supplied: bool = _follow_in_the_window(position)
 	Input.parse_input_event(_button(position, button, whole or held, double))
+	var lasted: Variant = null
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
 	elif whole:
 		# A frame between the halves at least, as inject_action has, so a control that acts on the
 		# press and one that acts on the release each get a frame to do it in.
-		await _held(frames)
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(position, button, false, false))
 		await _host.get_tree().process_frame
 
@@ -329,6 +312,7 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 				"type": "input_injected",
 				"input_type": "mouse_click",
 				"held_frames": GdhValues.held_answer(whole and not notch, frames),
+				"held_for": lasted,
 				"position": [position.x, position.y],
 				"button": button,
 				"pressed": held and not whole,

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

@@ -69,11 +69,11 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 	var frames: int = holding
 
 	Input.parse_input_event(_button(button, device, whole or held))
+	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a key has, so a game that acts on the press and one
 		# that acts on the release each get a frame to do it in.
-		for _frame: int in frames:
-			await _host.get_tree().process_frame
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(button, device, false))
 		await _host.get_tree().process_frame
 
@@ -81,6 +81,7 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 		"type": "input_injected",
 		"input_type": "joypad_button",
 		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
 		"button": button,
 		"button_name": _name_of(button, JOY_BUTTONS),
 		"device": device,

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## run off the game the node keeps. Every op that reads, writes, calls or waits on a game's state
 ## walks the same way, so the walk and what it says when a step is not there live in one place.
 
+const GdhRead = preload("reading.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhValues = preload("runtime_values.gd")
 
@@ -640,7 +641,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 			"%s has no property %s; it has a method of that name, which a path calls as %s()"
 			% [called_as, named, named]
 		)
-	return "%s has no property %s" % [called_as, named]
+	return GdhRead.near_property("%s has no property %s" % [called_as, named], object, named)
 
 
 ## Why [param method] is not a call a path makes on [param sort] ("a list", "a packed list" or "a

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

@@ -126,6 +126,36 @@ static func held_answer(whole: bool, frames: int) -> Variant:
 	return null
 
 
+## Waits out [param frames] process frames of [param tree], how long a whole press is held down,
+## and answers how long that was by the clock and in physics ticks. A process frame is no set
+## time: a headless game draws nothing and runs them as fast as it can, so thirty held a movement
+## read in _physics_process for twelve ticks, a fifth of a second, where a caller counting sixty
+## frames a second expected half of one.
+static func hold(tree: SceneTree, frames: int) -> Dictionary:
+	var began_usec: int = Time.get_ticks_usec()
+	var began_tick: int = Engine.get_physics_frames()
+	for _frame: int in frames:
+		await tree.process_frame
+	return {
+		"seconds": snappedf((Time.get_ticks_usec() - began_usec) / 1000000.0, 0.001),
+		"physics_frames": Engine.get_physics_frames() - began_tick,
+	}
+
+
+## The character a key produces, or nothing for a key that produces none.
+##
+## Godot's keycodes below [constant KEY_SPECIAL] are the Unicode code points of the keys that
+## print something, so the mapping is the value itself. Letters are held as their capitals, which
+## is the one place the shift a caller asked for changes the answer rather than the key: the small
+## letter is 32 above its capital.
+static func glyph_of(keycode: Key, shifted: bool) -> int:
+	if keycode >= KEY_SPECIAL:
+		return 0
+	if keycode >= KEY_A and keycode <= KEY_Z and not shifted:
+		return keycode + 32
+	return keycode
+
+
 ## What [param path] names: a node under [param root], as [method node_at] reads it, or an engine
 ## singleton by its name. Answers the object under "object", and under "node" the node that objects
 ## named in a value are found from, which for a singleton is [param root].

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

@@ -121,6 +121,10 @@ const BUILDERS: Dictionary = {
 	"Dictionary": "_build_dictionary",
 }
 
+## The built-in resources being described, outermost first, so one holding itself somewhere inside
+## is answered by its class rather than without end.
+var _describing: Array[Resource] = []
+
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
@@ -665,9 +669,21 @@ func _serialize_object(value: Object) -> Variant:
 		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
-		if resource.resource_path.is_empty():
-			return {"class": resource.get_class(), "_type": "Resource"}
-		return {"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"}
+		# A file's built-in resources load with a path of the file's own and "::", which no other
+		# file can refer to.
+		if resource.resource_path.is_empty() or resource.resource_path.contains("::"):
+			return _describe_built_in(resource)
+		var filed: Dictionary = {
+			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"
+		}
+		# The engine class of a resource with a script is the one its script extends, so a Stats
+		# file read as a Resource and nothing said it was a Stats.
+		var attached: Variant = resource.get_script()
+		if attached is Script:
+			var script: Script = attached
+			if not script.get_global_name().is_empty():
+				filed["scriptClass"] = str(script.get_global_name())
+		return filed
 	if value is Node:
 		var node: Node = value
 		if node.is_inside_tree():
@@ -675,6 +691,62 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## A resource built into the file it was read from, in the form a write builds one from: its class
+## under _type beside every property it stores away from its default. As its class alone it said
+## nothing of what it held, so a CollisionShape2D's radius could not be read, and it could not be
+## written back.
+func _describe_built_in(resource: Resource) -> Dictionary:
+	if _describing.has(resource):
+		return {"class": resource.get_class(), "_type": "Resource"}
+	_describing.append(resource)
+	var described: Dictionary = {"_type": resource.get_class()}
+	var attached: Variant = resource.get_script()
+	var script: Script = null
+	if attached is Script:
+		script = attached
+		described["script"] = serialize_value(script)
+	var fresh: Object = _fresh(script)
+	for property: Dictionary in resource.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or name == "script"
+			or (name.begins_with("resource_") and name != "resource_name")
+		):
+			continue
+		var held: Variant = resource.get(name)
+		var default: Variant = ClassDB.class_get_property_default_value(resource.get_class(), name)
+		if fresh != null:
+			default = fresh.get(name)
+		elif script != null and usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			default = script.get_property_default_value(name)
+		if typeof(held) == typeof(default) and held == default:
+			continue
+		described[name] = serialize_value(held)
+	_describing.pop_back()
+	return described
+
+
+## A new instance of [param script] to read defaults off, or null where none should be made. What
+## the script's own code sets as it is made (a resource_name in _init, a list built by a
+## constructor, which the engine reports no default for) is then a default rather than a value
+## the file holds. None is made for a script whose _init needs arguments, nor in the editor for one
+## that is not a tool: the editor never runs those, and can_instantiate says so.
+static func _fresh(script: Script) -> Object:
+	if script == null or not script.can_instantiate():
+		return null
+	for method: Dictionary in script.get_script_method_list():
+		if str(method.get("name", "")) == "_init":
+			var arguments: Array = method.get("args", [])
+			var defaults: Array = method.get("default_args", [])
+			if arguments.size() > defaults.size():
+				return null
+	# Called by name: new() is declared on each kind of script rather than on Script.
+	var made: Variant = script.call("new")
+	return made if made is Object else null
+
+
 ## An input event, by what it is bound to: the engine's own words for it and every field it stores
 ## away from its default. As a bare resource it was its class and nothing else, so an input action
 ## read back from project.godot could not say whether it was bound to Space or to a joypad button.