gdharness 1.3.40 → 1.3.42

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

@@ -10,6 +10,9 @@ const GdhSerialisation = preload("../serialisation.gd")
 
 ## What every emission meets when a connection cannot call its method.
 const FAILS: String = ", so every emission fails to call it."
+## The engine's CONNECT_INHERITED, which GDScript is not given: on a connection an instanced or
+## inherited scene makes, as a scene holding one loads it.
+const CONNECT_INHERITED: int = 32
 ## The names Object.ConnectFlags gives each bit. The number alone left a reader guessing that 2 is
 ## the persistence every connection in a saved scene carries.
 const CONNECT_FLAG_NAMES: Dictionary[int, String] = {
@@ -18,9 +21,7 @@ const CONNECT_FLAG_NAMES: Dictionary[int, String] = {
 	Object.CONNECT_ONE_SHOT: "one_shot",
 	Object.CONNECT_REFERENCE_COUNTED: "reference_counted",
 	Object.CONNECT_APPEND_SOURCE_OBJECT: "append_source_object",
-	# The engine's CONNECT_INHERITED, which GDScript is not given: on a connection an instanced scene
-	# makes inside itself, as a scene holding one loads it.
-	32: "inherited",
+	CONNECT_INHERITED: "inherited",
 }
 ## The flags a caller may give: the engine's own CONNECT_INHERITED marks a connection an instanced
 ## scene makes, and is never one a scene makes for itself.
@@ -295,7 +296,9 @@ static func _misfit(source: Node, signal_name: String, callable: Callable, flags
 			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))
+	var emitted: int = passed.size()
+	var unbound: int = callable.get_unbound_arguments_count()
+	passed = passed.slice(0, maxi(emitted - unbound, 0))
 	var from_signal: int = passed.size()
 	for bound: Variant in callable.get_bound_arguments():
 		var bound_class: String = ""
@@ -303,43 +306,58 @@ static func _misfit(source: Node, signal_name: String, callable: Callable, flags
 			var object: Object = bound
 			bound_class = object.get_class()
 		passed.append({"name": "bound", "type": typeof(bound), "class_name": bound_class})
+	var binds: int = passed.size() - from_signal
+
+	# What the method is called with, said in the parts that make it: an answer counting the bound
+	# arguments among the signal's said the signal passed more than it declares.
+	var called: String = "%s passes %s" % [signal_name, _count(emitted)]
+	if unbound > 0 or binds > 0:
+		var changed: Array[String] = []
+		if unbound > 0:
+			changed.append("unbinds %d" % unbound)
+		if binds > 0:
+			changed.append("binds %d" % binds)
+		called += (
+			" and the connection %s, so %s is called with %s, and"
+			% [" and ".join(PackedStringArray(changed)), method, _count(passed.size())]
+		)
+	else:
+		called += ", and " + method
 
 	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]
+		return "%s needs %d%s" % [called, needed, FAILS]
 	if passed.size() > parameters.size():
 		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
 		# Said with the misfit, since unbinds is what a connection to a method wanting less is for, and
-		# only when the extra arguments are the signal's: a bound one is not dropped by unbinding.
+		# only when the extra arguments are the signal's: a scene's connection unbinds the arguments
+		# the signal passes before it adds the bound ones, so a bound one is never dropped.
 		var extra: int = passed.size() - parameters.size()
 		var remedy: String = (
 			(
-				" Connected with unbinds %d, the last %s the signal passes %s left out."
-				% [
-					extra + callable.get_unbound_arguments_count(),
-					"argument" if extra == 1 else "%d arguments" % extra,
-					"is" if extra == 1 else "are",
-				]
+				" Connect it with unbinds %d to leave out the last %s the signal passes."
+				% [extra + unbound, "argument" if extra == 1 else "%d arguments" % extra]
 			)
 			if extra <= from_signal
 			else ""
 		)
-		return (
-			"%s passes %s, and %s takes %s%s%s"
-			% [signal_name, _count(passed.size()), method, most, FAILS, remedy]
-		)
+		return "%s takes %s%s%s" % [called, most, FAILS, remedy]
 	for at: int in passed.size():
 		var given: Dictionary = passed[at]
 		var parameter: Dictionary = parameters[at]
 		if not _unrelated(given, parameter):
 			continue
+		var whose: String = (
+			"%s passes argument %d" % [signal_name, at + 1]
+			if at < from_signal
+			else "the connection binds argument %d" % (at + 1)
+		)
 		return (
-			"%s passes argument %d as %s, and %s takes it as %s: %s%s"
+			"%s as %s, and %s takes it as %s: %s%s"
 			% [
-				signal_name,
-				at + 1,
+				whose,
 				_type_named(given),
 				method,
 				str(parameter.get("name", "")),
@@ -380,6 +398,25 @@ static func _type_named(declared: Dictionary) -> String:
 	return type_string(type)
 
 
+## The scene that makes the connection [param source] holds with [param flags], as a path, or "" for
+## one this scene makes. The engine marks such a connection inherited as the scene holding it loads:
+## from an instance, the scene instanced, and from the root of an inherited scene, the one it
+## inherits.
+static func _made_in(scene: GdhSceneFile, source: Node, flags: int) -> String:
+	if not flags & CONNECT_INHERITED:
+		return ""
+	if source != scene.root and not source.scene_file_path.is_empty():
+		return source.scene_file_path
+	var holder: Node = source if source == scene.root else source.owner
+	while holder != null and holder != scene.root and holder.scene_file_path.is_empty():
+		holder = holder.owner
+	if holder != null and holder != scene.root:
+		return holder.scene_file_path
+	var packed: PackedScene = load(scene.path) as PackedScene
+	var base: SceneState = packed.get_state().get_base_scene_state() if packed != null else null
+	return base.get_path() if base != null else "a scene this one inherits"
+
+
 static func _count(arguments: int) -> String:
 	if arguments == 0:
 		return "no arguments"
@@ -428,6 +465,21 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 				% [scene_path, said_from, signal_name, said_to, method_name]
 			)
 		)
+	var made_in: String = _made_in(scene, source, GdhRead.as_int(held["flags"]))
+	if not made_in.is_empty():
+		var named_from: String = str(source.name) if source == scene.root else from
+		var named_to: String = str(target.name) if target == scene.root else to
+		var made_by: String = (
+			"The connection from %s.%s to %s.%s is made by %s"
+			% [named_from, signal_name, named_to, method_name, made_in]
+		)
+		return scene.refuse(
+			(
+				made_by
+				+ ", and this scene saves nothing about it: disconnect it there, which changes every"
+				+ " scene using it."
+			)
+		)
 	var callable: Callable = held["callable"]
 	source.disconnect(signal_name, callable)
 
@@ -498,6 +550,9 @@ func list_connections(args: Dictionary) -> Dictionary:
 				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()
+				# A connection an instanced scene makes on its own root sits on a node this scene owns,
+				# so the ends alone read it as one this scene could change.
+				var made_in: String = _made_in(scene, node, flags)
 				var listed: Dictionary = {
 					"sourceNodePath": path,
 					"signalName": signal_name,
@@ -505,11 +560,11 @@ func list_connections(args: Dictionary) -> Dictionary:
 					"methodName": str(callable.get_method()),
 					"flags": flags,
 					"flagNames": flag_names(flags),
-					# False for a connection an instanced scene makes inside itself, which only that
-					# scene can change.
-					"editable": editable,
+					"editable": editable and made_in.is_empty(),
 					"methodFound": target_obj != null and target_obj.has_method(callable.get_method()),
 				}
+				if not made_in.is_empty():
+					listed["madeIn"] = made_in
 				var bound: Dictionary = {
 					"binds": callable.get_bound_arguments(),
 					"unbinds": callable.get_unbound_arguments_count(),

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

@@ -26,6 +26,7 @@ const CHANGES: String = "runtime_changes.gd"
 const INPUT: String = "runtime_input.gd"
 const TYPING: String = "runtime_typing.gd"
 const PAD: String = "runtime_pad.gd"
+const TOUCH: String = "runtime_touch.gd"
 const CAPTURE: String = "runtime_capture.gd"
 const WAITS: String = "runtime_waits.gd"
 const ACCESSIBILITY: String = "runtime_accessibility.gd"
@@ -52,6 +53,8 @@ const MODULE_COMMANDS: Dictionary = {
 	"inject_mouse_drag": [INPUT, "inject_mouse_drag"],
 	"inject_joypad_button": [PAD, "inject_joypad_button"],
 	"inject_joypad_motion": [PAD, "inject_joypad_motion"],
+	"inject_touch": [TOUCH, "inject_touch"],
+	"inject_touch_drag": [TOUCH, "inject_touch_drag"],
 	"click": [INPUT, "click"],
 	"choose": [TYPING, "choose"],
 	"wait_frames": [WAITS, "wait_frames"],
@@ -218,7 +221,7 @@ func _module(file: String) -> Object:
 	match file:
 		QUERIES:
 			made = script.new(self, values, _frames)
-		TYPING, PAD, ACCESSIBILITY:
+		TYPING, PAD, TOUCH, ACCESSIBILITY:
 			made = script.new(self)
 		_:
 			made = script.new(self, values)

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

@@ -96,11 +96,12 @@ static func where(aim: Dictionary, viewport: Viewport, points: Array[Vector2]) -
 
 
 ## The points of a drag: x, y, then each of via, then toX, toY. Answers the String saying what is
-## wrong instead, since a point left out would otherwise read as the window's corner.
-static func stroke_of(params: Dictionary) -> Variant:
+## wrong instead, since a point left out would otherwise read as the window's corner. [param op] is
+## the drag the refusal names.
+static func stroke_of(params: Dictionary, op: String = "mouse_drag") -> Variant:
 	for key: String in ["x", "y", "toX", "toY"]:
 		if not params.has(key):
-			return "mouse_drag needs x, y, toX and toY: %s is missing." % key
+			return "%s needs x, y, toX and toY: %s is missing." % [op, key]
 	var points: Array[Vector2] = [Vector2(GdhRead.as_float(params["x"]), GdhRead.as_float(params["y"]))]
 	var via: Variant = params.get("via", [])
 	if not via is Array:

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

@@ -0,0 +1,211 @@
+extends RefCounted
+
+## What reaches the running game the way a touchscreen reaches it: a finger pressed, held, lifted
+## and dragged, as InputEventScreenTouch and InputEventScreenDrag.
+##
+## The events themselves rather than a mouse standing in for them: input code tells a finger from a
+## mouse by the event's class, or by the mouse events the engine makes from a touch, which carry
+## InputEvent.DEVICE_ID_EMULATION. A mouse_click carries the mouse's own device, so a game switching
+## its glyphs or focus on a touch never saw one. Sent through Input for the game's window, so the
+## engine makes those mouse events itself where input_devices/pointing/emulate_mouse_from_touch is on.
+
+const GdhRead = preload("reading.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhMouse = preload("runtime_mouse.gd")
+
+const EMULATE_SETTING: String = "input_devices/pointing/emulate_mouse_from_touch"
+
+var _host: Node
+# The finger the engine makes mouse events from, as Input keeps it for the touches sent here: the
+# first one pressed while none is, until it lifts. -1 for none.
+var _emulating: int = -1
+
+
+func _init(host: Node) -> void:
+	_host = host
+
+
+## Presses a finger at a position, and lifts it a frame later unless asked to hold it, as
+## inject_mouse_click does a button: a finger left down is a touch that never ends.
+func inject_touch(params: Dictionary) -> Dictionary:
+	var root: Window = _host.get_tree().root
+	var aimed: Variant = GdhMouse.aim_of(params, root)
+	if aimed is String:
+		return {"type": "error", "message": aimed}
+	var aim: Dictionary = aimed
+	var point: Variant = GdhMouse.read_point(params, "x", "y")
+	if point is String:
+		return {"type": "error", "message": point}
+	var finger: Variant = _finger_of(params)
+	if finger is String:
+		return {"type": "error", "message": finger}
+	var index: int = finger
+	var holding: Variant = GdhValues.held_for(params)
+	if holding is String:
+		return {"type": "error", "message": holding}
+	var frames: int = holding
+	var local: Vector2 = point
+	var placed: Dictionary = GdhMouse.carried(aim, local, root)
+	var viewport: Viewport = placed["viewport"]
+	var position: Vector2 = placed["position"]
+	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
+	var whole: bool = not params.has("pressed")
+
+	var at: Array[Vector2] = [position]
+	var where: Dictionary = GdhMouse.where(aim, viewport, at)
+	var emulates: bool = _send(viewport, _touch(position, index, whole or held))
+	var lasted: Variant = null
+	if whole:
+		lasted = await GdhValues.hold(_host.get_tree(), frames)
+		var _lifted: bool = _send(viewport, _touch(position, index, false))
+	await _host.get_tree().process_frame
+
+	var answer: Dictionary = {
+		"type": "input_injected",
+		"input_type": "touch",
+		"index": index,
+		"position": [position.x, position.y],
+		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
+		"pressed": held and not whole,
+		"whole": whole,
+		"emulates_mouse": emulates,
+	}
+	answer.merge(where)
+	return answer
+
+
+## Drags a finger from one point to another through any between: the touch, one drag each process
+## frame along the stroke, and the lift where the last drag left it, a frame after it. Each drag goes
+## in a frame of its own because the engine merges the drags it is given within one frame, as it
+## merges a mouse's motions.
+func inject_touch_drag(params: Dictionary) -> Dictionary:
+	var root: Window = _host.get_tree().root
+	var aimed: Variant = GdhMouse.aim_of(params, root)
+	if aimed is String:
+		return {"type": "error", "message": aimed}
+	var aim: Dictionary = aimed
+	var stroke: Variant = GdhMouse.stroke_of(params, "touch_drag")
+	if stroke is String:
+		return {"type": "error", "message": stroke}
+	var finger: Variant = _finger_of(params)
+	if finger is String:
+		return {"type": "error", "message": finger}
+	var index: int = finger
+	var frames: int = GdhRead.as_int(params.get("frames", 0), 0)
+	if frames < 1 or frames > GdhValues.MOST_HELD:
+		return {
+			"type": "error", "message": "frames is %d, and it takes 1 to %d." % [frames, GdhValues.MOST_HELD]
+		}
+	# Carried once, before the touch: a finger drags across the screen, not along a node that moves.
+	var named: Array[Vector2] = stroke
+	var points: Array[Vector2] = []
+	var viewport: Viewport = root
+	for local: Vector2 in named:
+		var placed: Dictionary = GdhMouse.carried(aim, local, root)
+		viewport = placed["viewport"]
+		points.append(placed["position"])
+
+	var lengths: Array[float] = GdhMouse.lengths_of(points)
+	var start: Vector2 = points[0]
+	var end: Vector2 = points[points.size() - 1]
+	var where: Dictionary = GdhMouse.where(aim, viewport, points)
+	var emulates: bool = _send(viewport, _touch(start, index, true))
+	var last: Vector2 = start
+	var travelled: Vector2 = Vector2.ZERO
+	for step: int in range(1, frames + 1):
+		await _host.get_tree().process_frame
+		if not is_instance_valid(viewport):
+			return {
+				"type": "error",
+				"message":
+				(
+					(
+						"%s was freed after the touch and %d of %d drags, so the rest of the stroke"
+						+ " and the lift went nowhere"
+					)
+					% [where.get("window", "The window"), step - 1, frames]
+				)
+			}
+		var at: Vector2 = GdhMouse.along(points, lengths, float(step) / frames)
+		var relative: Vector2 = at - last
+		last = at
+		travelled += relative
+		var _dragged: bool = _send(viewport, _drag(at, relative, index))
+	await _host.get_tree().process_frame
+	var _lifted: bool = _send(viewport, _touch(end, index, false))
+	await _host.get_tree().process_frame
+
+	var answer: Dictionary = {
+		"type": "input_injected",
+		"input_type": "touch_drag",
+		"index": index,
+		"from": [start.x, start.y],
+		"to": [end.x, end.y],
+		"motions": frames,
+		"relative_total": [travelled.x, travelled.y],
+		"emulates_mouse": emulates,
+	}
+	answer.merge(where)
+	return answer
+
+
+## The finger [param params].index names, 0 when none is given, or the String refusing it.
+static func _finger_of(params: Dictionary) -> Variant:
+	if not params.has("index"):
+		return 0
+	var given: Variant = params["index"]
+	var number: float = GdhRead.as_float(given)
+	if not (given is int or given is float) or number != roundf(number):
+		return "index is the finger, a whole number from 0, and was %s." % JSON.stringify(given)
+	var index: int = roundi(number)
+	if index < 0:
+		return "index is the finger, a whole number from 0, and was %d." % index
+	return index
+
+
+## Sends [param event] into [param viewport]: through Input for the game's window, and pushed into
+## any other, since Input reaches only the game's window. Answers whether the engine makes a mouse
+## event from it, which it does in Input, with the setting on, for one finger at a time.
+func _send(viewport: Viewport, event: InputEvent) -> bool:
+	if viewport != _host.get_tree().root:
+		if is_instance_valid(viewport):
+			viewport.push_input(event)
+		return false
+	Input.parse_input_event(event)
+	if not GdhRead.as_bool(ProjectSettings.get_setting(EMULATE_SETTING, true), true):
+		return false
+	var touch: InputEventScreenTouch = event as InputEventScreenTouch
+	if touch == null:
+		return (event as InputEventScreenDrag).index == _emulating
+	if touch.pressed:
+		if _emulating != -1:
+			return false
+		_emulating = touch.index
+		return true
+	if touch.index != _emulating:
+		return false
+	_emulating = -1
+	return true
+
+
+static func _touch(position: Vector2, index: int, pressed: bool) -> InputEventScreenTouch:
+	var event: InputEventScreenTouch = InputEventScreenTouch.new()
+	event.index = index
+	event.position = position
+	event.pressed = pressed
+	return event
+
+
+## A drag carrying [param relative] as the movement since the last, and the speed that is at the
+## frame rate the game runs at.
+func _drag(position: Vector2, relative: Vector2, index: int) -> InputEventScreenDrag:
+	var event: InputEventScreenDrag = InputEventScreenDrag.new()
+	event.index = index
+	event.position = position
+	event.relative = relative
+	event.screen_relative = relative
+	var seconds: float = maxf(_host.get_process_delta_time(), 1.0 / 60.0)
+	event.velocity = relative / seconds
+	event.screen_velocity = event.velocity
+	return event

package/build/godot/addons/gdharness_runtime/runtime_touch.gd.uid

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

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

@@ -112,11 +112,15 @@ static func field_before(focused: Control) -> Dictionary:
 ## Whether [param focused], read as [param before], stopped being edited, as a [LineEdit] does when
 ## it is submitted: it keeps the focus and drops every key after, so a caller reading only the focus
 ## typed next into nothing.
-static func ended_editing(focused: Control, before: Dictionary) -> bool:
+##
+## [param focused] is a Variant because the key can free it, as Escape closing the panel a field is
+## on does, and a parameter typed Control refuses a freed object before the check here can run.
+static func ended_editing(focused: Variant, before: Dictionary) -> bool:
 	var was: bool = before.get("editing", false)
 	if not was or not is_instance_valid(focused):
 		return false
-	var field: LineEdit = focused as LineEdit
+	var held: Object = focused
+	var field: LineEdit = held as LineEdit
 	return field != null and not field.is_editing()
 
 
@@ -124,15 +128,18 @@ static func ended_editing(focused: Control, before: Dictionary) -> bool:
 ## typed_into and holds where its text changed, and editing_ended where it stopped being edited. A
 ## field being edited takes a printable key as typing and keeps it from the game's _unhandled_input,
 ## so Space into a name field pressed no jump, and an answer naming only the focus did not say why.
-static func field_noted(said: Dictionary, focused: Control, before: Dictionary) -> Dictionary:
+## A Variant for the reason [method ended_editing] gives.
+static func field_noted(said: Dictionary, focused: Variant, before: Dictionary) -> Dictionary:
 	if before.is_empty() or not is_instance_valid(focused):
 		return said
-	var field: LineEdit = focused as LineEdit
-	var now: String = field.text if field != null else (focused as TextEdit).text
+	var held: Object = focused
+	var control: Control = held as Control
+	var field: LineEdit = control as LineEdit
+	var now: String = field.text if field != null else (control as TextEdit).text
 	if now != before["text"]:
-		said["typed_into"] = str(focused.get_path())
-		said["holds"] = _what_it_holds(focused)
-	if ended_editing(focused, before):
+		said["typed_into"] = str(control.get_path())
+		said["holds"] = _what_it_holds(control)
+	if ended_editing(control, before):
 		said["editing_ended"] = true
 	return said
 

package/build/godot/operations/animation_reads.gd

@@ -64,7 +64,13 @@ static func scene_states(scene_path: String, tree_path: String, state_machine_pa
 			player_path = "."
 		var found: Array = _bare(scene_path, player_path, "AnimationPlayer")
 		player = found[0]
-	var answer: Dictionary = states(tree, state_machine_path, player, player_path)
+	var reached: Node = null
+	if player == null and not player_path.is_empty():
+		reached = _bare(scene_path, player_path, "Node")[0]
+	var unplayed: String = no_player(str(tree.anim_player), reached)
+	if reached != null:
+		reached.free()
+	var answer: Dictionary = states(tree, state_machine_path, player, player_path, unplayed)
 	tree.free()
 	if player != null:
 		player.free()
@@ -236,6 +242,20 @@ static func no_machine(tree: AnimationTree, state_machine_path: String) -> Strin
 	return "No state machine at " + state_machine_path
 
 
+## Why no state finds its animation when [param anim_player], an AnimationTree's path to its
+## player, reaches no AnimationPlayer: [param reached] is the node it reaches instead, null for none.
+static func no_player(anim_player: String, reached: Node) -> String:
+	var until: String = "so no state plays anything until scene_node set points anim_player at one."
+	if anim_player.is_empty():
+		return "The AnimationTree has no anim_player, " + until
+	if reached == null:
+		return "The AnimationTree's anim_player %s reaches no node, %s" % [anim_player, until]
+	return (
+		"The AnimationTree's anim_player %s reaches %s, a %s rather than an AnimationPlayer, %s"
+		% [anim_player, reached.name, reached.get_class(), until]
+	)
+
+
 ## Why a state playing [param animation_name] from [param player], at [param player_path] from the
 ## scene root as playerNodePath takes it, plays nothing yet. anim_player is relative to the tree
 ## ("../Anim"), which no argument takes.
@@ -254,9 +274,14 @@ static func missing_animation(player: AnimationPlayer, player_path: String, anim
 
 ## The states and transitions of the state machine at [param state_machine_path] in [param tree].
 ## A state playing an animation says whether [param player], at [param player_path], has it, as
-## add_state answers: a state naming one it lacks plays nothing, and says so only in a log.
+## add_state answers: a state naming one it lacks plays nothing, and says so only in a log. With no
+## player, each says [param unplayed], what [method no_player] made of the tree's path.
 static func states(
-	tree: AnimationTree, state_machine_path: String, player: AnimationPlayer, player_path: String
+	tree: AnimationTree,
+	state_machine_path: String,
+	player: AnimationPlayer,
+	player_path: String,
+	unplayed: String
 ) -> Dictionary:
 	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
 	if sm == null:
@@ -270,7 +295,9 @@ static func states(
 			entry["animationName"] = str(plays.animation)
 			var found: bool = player != null and player.has_animation(plays.animation)
 			entry["animationFound"] = found
-			if player != null and not found:
+			if player == null:
+				entry["animationMissing"] = unplayed
+			elif not found:
 				entry["animationMissing"] = missing_animation(player, player_path, str(plays.animation))
 		listed.append(entry)
 	var transitions: Array[Dictionary] = []

package/build/godot/operations/dependencies.gd

@@ -428,7 +428,10 @@ func _declared_class_name(path: String) -> String:
 func _usage_files(kinds: Array) -> Array[String]:
 	var found: Array[String] = []
 	for kind: Variant in kinds:
-		match str(kind):
+		# As project_search reads an extension: ".tscn" searched no file, and the answer said
+		# nothing used a script its scene attaches.
+		var named: String = str(kind).trim_prefix(".").to_lower()
+		match named:
 			"godot":
 				found.append("res://project.godot")
 			"cfg":
@@ -436,7 +439,7 @@ func _usage_files(kinds: Array) -> Array[String]:
 				if FileAccess.file_exists("res://export_presets.cfg"):
 					found.append("res://export_presets.cfg")
 			_:
-				found.append_array(_files.find_files("res://", "." + str(kind)))
+				found.append_array(_files.find_files("res://", "." + named))
 	return found
 
 

package/build/godot/operations/file_reads.gd

@@ -11,6 +11,7 @@ extends RefCounted
 ## initialisers run, and a resource with a script is made with it.
 
 const GdhRead = preload("reading.gd")
+const GdhFileWalk = preload("file_walk.gd")
 const GdhSame = preload("same_values.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhShapes = preload("value_shapes.gd")
@@ -487,7 +488,7 @@ static func _stored(type: String, given: Dictionary, include_defaults: bool) ->
 static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	var file: String = res_path.get_slice("::", 0)
 	if not FileAccess.file_exists(file):
-		return {"ok": false, "error": "No resource at " + file}
+		return {"ok": false, "error": GdhFileWalk.new().with_nearest_files("No resource at " + file, file)}
 	var whole: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if whole == null:
 		return {"ok": false, "error": "%s did not load as a resource." % file}
@@ -516,6 +517,18 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 			scripted[str(declared.get("name", ""))] = true
 	var serialiser: GdhSerialisation = GdhSerialisation.new()
 	var properties: Dictionary = {}
+	# A headless engine runs a script that is not a tool as the file loads, so what its _init and
+	# setters gave other properties read as values the file sets; the file's own lines say which it
+	# does. The editor runs no such script.
+	var untooled: bool = script != null and not script.is_tool() and not Engine.is_editor_hint()
+	var from_file: bool = (
+		untooled and file.ends_with(".tres") and not GdhShapes.STORED_APART.has(loaded.get_class())
+	)
+	var set_in_file: Dictionary = (
+		_names_set_in(FileAccess.get_file_as_string(file), res_path.trim_prefix(file).trim_prefix("::"))
+		if from_file
+		else {}
+	)
 	# A Curve's points are read off one with none, since the engine has no default for point_0.
 	var fresh: Object = (
 		ClassDB.instantiate(loaded.get_class()) if GdhShapes.STORED_APART.has(loaded.get_class()) else null
@@ -537,6 +550,8 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 			)
 			if GdhSame.same(value, default):
 				continue
+			if from_file and not set_in_file.has(property):
+				continue
 		properties[property] = serialiser.serialize_value(value)
 	var answer: Dictionary = {
 		"ok": true, "resourcePath": res_path, "resourceType": loaded.get_class(), "properties": properties
@@ -551,6 +566,26 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	return answer
 
 
+## The names the [code][resource][/code] section of [param text], a .tres file, sets, or those of the
+## embedded resource with the id [param id] when one is given, as a set.
+static func _names_set_in(text: String, id: String) -> Dictionary:
+	var names: Dictionary = {}
+	var inside: bool = false
+	var key: RegEx = RegEx.create_from_string("^([^\\s=\\[][^=]*?) = ")
+	for line: String in text.split("\n"):
+		if line.begins_with("["):
+			inside = (
+				line.begins_with("[resource]")
+				if id.is_empty()
+				else line.begins_with("[sub_resource") and line.contains('id="%s"' % id)
+			)
+			continue
+		var found: RegExMatch = key.search(line) if inside else null
+		if found != null:
+			names[found.get_string(1)] = true
+	return names
+
+
 ## The resource [param file] keeps under [param id], found in [param value] or anything it holds.
 ## The engine loads such a path only while the file is cached, and a read loads the file uncached,
 ## so it is looked for among what the file holds. A resource of another file is neither taken nor