gdharness 1.3.41 → 1.3.42

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

@@ -246,6 +246,7 @@ func create_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
+	_note_put_back(answer, resource, res_path)
 	if not properties.is_empty():
 		answer["properties"] = _held(resource, properties.keys())
 	return answer
@@ -302,10 +303,24 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	var failed: String = _save_checked(resource, res_path, properties.keys(), previous)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
+	_note_put_back(answer, resource, res_path)
 	answer["properties"] = _held(resource, properties.keys())
 	return answer
 
 
+## Moves to setByScript each property alsoChanged in [param answer] gave a value [param resource] no
+## longer holds once saved at [param path]: the save put it back as its script's doing.
+func _note_put_back(answer: Dictionary, resource: Resource, path: String) -> void:
+	var noted: Dictionary = answer.get("alsoChanged", {})
+	var restored: Array = []
+	for key: Variant in noted:
+		var now: Variant = _values.serialize_value(_properties.read_at(resource, str(key)))
+		var entry: Dictionary = noted[key]
+		if JSON.stringify(now) != JSON.stringify(entry.get("now")):
+			restored.append(key)
+	GdhHeadlessCheck.move_script_set(answer, restored, path)
+
+
 ## Why [param resource], saved at [param path], cannot hold what [param names] were given, or "": a
 ## resource cannot hold the file it is saved as. Godot saves the reference as null with only a
 ## warning in its log, and the read back after the save reported the property as one the file does

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

@@ -126,8 +126,13 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"rootNodeType": root_type,
 		"rootNodeName": name
 	}
-	if script != null:
-		answer["script"] = script.resource_path
+	var properties: Dictionary = base["properties"]
+	var carried: Variant = script if script != null else properties.get("script")
+	if carried is Script:
+		var carried_script: Script = carried
+		answer["script"] = carried_script.resource_path
+		if not str(carried_script.get_global_name()).is_empty():
+			answer["scriptClass"] = str(carried_script.get_global_name())
 	return answer
 
 

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

@@ -0,0 +1,59 @@
+@tool
+extends RefCounted
+
+## Where else in a scene a resource built into it is held, since such a resource is one object
+## wherever the scene uses it.
+
+const GdhPropertyPaths = preload("../property_paths.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+
+
+## Every other place in [param scene] holding a resource that [param key] was written through on
+## [param node], as {node, property}. A copy made by duplicate shares its original's resources, so
+## the write changed each of them too.
+static func holders(scene: GdhSceneFile, node: Node, key: String) -> Array[Dictionary]:
+	var found_at: Array[Dictionary] = []
+	var through: Array = GdhPropertyPaths.holder_of(node, key, GdhPropertyPaths.home_of(node))[2]
+	if through.is_empty():
+		return found_at
+	var wanted: Dictionary = {}
+	for reached: Resource in through:
+		wanted[reached.get_instance_id()] = true
+	var nodes: Array[Node] = [scene.root]
+	nodes.append_array(scene.root.find_children("*", "", true, false))
+	for at: Node in nodes:
+		for declared: Dictionary in at.get_property_list():
+			var property: String = str(declared.get("name", ""))
+			if property.is_empty() or not (GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+				continue
+			for found: String in _paths_to(at.get(property), property, wanted, {}):
+				if at != node or not key.begins_with(found + "/"):
+					found_at.append({"node": scene.path_of(at), "property": found})
+	return found_at
+
+
+## The paths below [param path] at which [param value] holds a resource of [param wanted], by
+## instance id, stepping into lists and into resources built into a scene.
+static func _paths_to(value: Variant, path: String, wanted: Dictionary, seen: Dictionary) -> Array[String]:
+	var paths: Array[String] = []
+	if value is Array:
+		var items: Array = value
+		for index: int in items.size():
+			paths.append_array(_paths_to(items[index], "%s/%d" % [path, index], wanted, seen))
+		return paths
+	if not value is Resource:
+		return paths
+	var held: Resource = value
+	var id: int = held.get_instance_id()
+	if wanted.has(id):
+		paths.append(path)
+	var built_in: bool = held.resource_path.is_empty() or held.resource_path.contains("::")
+	if seen.has(id) or not built_in:
+		return paths
+	seen[id] = true
+	for declared: Dictionary in held.get_property_list():
+		var property: String = str(declared.get("name", ""))
+		if not property.is_empty() and GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+			paths.append_array(_paths_to(held.get(property), path + "/" + property, wanted, seen))
+	return paths

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

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

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

@@ -15,6 +15,7 @@ const GdhPlacing = preload("scene_placing.gd")
 const GdhPropertyValues = preload("../property_values.gd")
 const GdhSame = preload("../same_values.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneSharing = preload("scene_sharing.gd")
 const GdhSerialisation = preload("../serialisation.gd")
 const GdhTilesetTools = preload("tileset_tools.gd")
 
@@ -43,7 +44,16 @@ func _kept(scene: GdhSceneFile, saved: Node, node: Node, names: Array) -> String
 	for key: Variant in names:
 		var property: String = str(key)
 		var loaded: Variant = _properties.read_at(copy, property)
-		if not scene.kept(saved, loaded, _properties.read_at(node, property)):
+		var given: Variant = _properties.read_at(node, property)
+		if not scene.kept(saved, loaded, given):
+			# The file holds it, and the copy's own script set it again as the copy loaded, as it will
+			# wherever the scene loads; an editor saves the same.
+			if scene.stores(at, property, given):
+				var on: Dictionary = scene.loads_as.get_or_add(at, {})
+				if GdhHeadlessCheck.untooled(copy.get_script()):
+					scene.loads_untooled[at] = true
+				on[property] = _values.serialize_value(loaded)
+				continue
 			return (
 				(
 					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
@@ -317,6 +327,7 @@ func add_node(args: Dictionary) -> Dictionary:
 	_properties.note_write(answer, new_node)
 	if not adding.is_empty():
 		answer.merge(GdhGroups.read_added(new_node, adding))
+	var id: int = new_node.get_instance_id()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(
@@ -329,6 +340,8 @@ func add_node(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
+	_note_put_back(answer, scene, id, new_path)
+	_note_loads_as(answer, scene, new_path)
 	if packed != null:
 		answer["instanceOf"] = instance_path
 	return answer
@@ -519,6 +532,7 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	for property: String in GdhPlacing.placing(node):
 		drawn_at[property] = _properties.read_at(node, property)
 	var held_at: Transform3D = (node as Node3D).transform if node is Node3D else Transform3D.IDENTITY
+	var stored_before: Dictionary = GdhHeadlessCheck.stored(node)
 	# Unowned while it moves: a node taken out of the tree keeps its owner, and adding it under the new
 	# parent warned that the owner was not above it. Node.reparent warns the same way.
 	node.owner = null
@@ -528,6 +542,11 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	GdhPlacing.own(node, root)
 	if GdhRead.as_bool(args.get("keepGlobalTransform", true)):
 		GdhPlacing.keep_in_place(node, old_parent)
+		# Unasked, a headless write takes the move on a node whose script is not a tool for the
+		# script's doing and puts the node back as the file held it.
+		var placed: Array[String] = GdhHeadlessCheck.differing(node, stored_before, {})
+		if not placed.is_empty():
+			scene.asked(node, placed)
 	var also_changed: Dictionary = {}
 	for property: String in drawn_at:
 		var now: Variant = _properties.read_at(node, property)
@@ -644,6 +663,13 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var new_path: String = scene.path_of(node)
 	var answer: Dictionary = {"ok": true, "nodePath": new_path, "properties": held}
 	_properties.note_write(answer, node)
+	var shared: Dictionary = {}
+	for key: Variant in properties:
+		var holders: Array[Dictionary] = GdhSceneSharing.holders(scene, node, str(key))
+		if not holders.is_empty():
+			shared[str(key)] = holders
+	if not shared.is_empty():
+		answer["sharedWith"] = shared
 	if not adding.is_empty() or not removing.is_empty():
 		answer["groups"] = GdhGroups.read(scene, node).get("groups", [])
 	var named: Array[String] = []
@@ -654,6 +680,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var source: String = scene.values_from(node, old_path)
 	var carried: GdhPaths = GdhPaths.new()
 	var _rewritten: int = carried.carry(scene, {old_path: new_path} if new_path != old_path else {})
+	var id: int = node.get_instance_id()
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(scene, saved, node, properties.keys())
@@ -675,12 +702,48 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	if not dropped.is_empty():
 		answer["droppedValues"] = dropped["values"]
 		answer["droppedNodes"] = dropped["nodes"]
+	_note_put_back(answer, scene, id, new_path)
+	_note_loads_as(answer, scene, new_path)
 	_note_left_out(answer, scene.written_pack, new_path, named, source)
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
 
 
+## Puts under loadsAs in [param answer] each value given that the file holds and the script of the
+## node at [param at] changes as the scene loads, as it loads.
+static func _note_loads_as(answer: Dictionary, scene: GdhSceneFile, at: String) -> void:
+	var on: Dictionary = scene.loads_as.get(at, {})
+	if on.is_empty():
+		return
+	answer["loadsAs"] = on
+	var names: Array = on.keys()
+	var pronoun: String = "it" if names.size() == 1 else "them"
+	if scene.loads_untooled.has(at):
+		answer["loadsAsNote"] = (
+			(
+				"The file holds %s as given, which the editor shows. %s's script is not a tool, so in the "
+				+ "game it runs as the scene loads and changes %s to what loadsAs gives."
+			)
+			% [", ".join(names), at, pronoun]
+		)
+	else:
+		answer["loadsAsNote"] = (
+			(
+				"The file holds %s as given. %s's script runs as the scene loads, in the editor and in "
+				+ "the game, and changes %s to what loadsAs gives."
+			)
+			% [", ".join(names), at, pronoun]
+		)
+
+
+## Moves out of alsoChanged in [param answer] what the last write of [param scene] put back on the
+## node with instance id [param id], at [param at], to setByScript.
+static func _note_put_back(answer: Dictionary, scene: GdhSceneFile, id: int, at: String) -> void:
+	var restored: Dictionary = scene.restored_by_write.get(id, {})
+	GdhHeadlessCheck.move_script_set(answer, restored.keys(), at)
+
+
 ## Notes under notStored each of [param named] the file saved from [param pack] does not set on the
 ## node at [param at]: a set gave it the value the node has without it, so the packer leaves it out,
 ## as the editor does, and it follows [param source], or its default, from then on.

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/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/file_reads.gd

@@ -517,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
@@ -538,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
@@ -552,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

package/build/godot/operations/gdscript_analysis.gd

@@ -249,6 +249,16 @@ func _members(
 				i += 1
 				stripped = (stripped + " " + GdhPatterns.without_comment(lines[i])).strip_edges()
 			header = GdhPatterns.without_annotations(stripped)
+		# A value that opens a triple-quoted string ends where the string does, and read from its
+		# first line alone it was the opening quotes and the text up to the line break.
+		if in_multiline_string and (header.begins_with("const ") or _declares_variable(header)):
+			while i + 1 < lines.size():
+				i += 1
+				stripped += "\n" + lines[i]
+				if _triple_quotes(lines[i]) % 2 == 1:
+					break
+			in_multiline_string = false
+			header = GdhPatterns.without_annotations(stripped)
 		var declaration: RegExMatch = GdhPatterns.declared_class(header)
 		var entry: Dictionary = {}
 		if declaration != null:
@@ -273,7 +283,7 @@ func _members(
 		elif header.begins_with("enum "):
 			entry = _parse_enum(header, at + 1)
 			own.enums.append(entry)
-		elif header.begins_with("var ") or header.begins_with("static var "):
+		elif _declares_variable(header):
 			# The whole line here, not the header: which annotations a variable carries is the
 			# answer rather than noise in front of it, and `@export_range(0, 1)` is the hint.
 			entry = _parse_variable(stripped, at + 1)
@@ -602,6 +612,10 @@ func _parse_variable(line: String, line_num: int) -> Dictionary:
 		return {"name": "", "line": line_num}
 
 	var var_text: String = line.substr(var_pos + 4).strip_edges()
+	# A colon closing the line opens the variable's setter and getter, and was read as the end of
+	# its default: `= Kind.ROUND:`.
+	if var_text.ends_with(":"):
+		var_text = var_text.left(-1).strip_edges()
 	var name: String = ""
 	var type_hint: String = ""
 	var default_value: String = ""
@@ -847,6 +861,10 @@ func _collect_dependencies(line: String, into: Array[String]) -> void:
 
 
 # How many triple quotes of either kind [param line] holds.
+static func _declares_variable(header: String) -> bool:
+	return header.begins_with("var ") or header.begins_with("static var ")
+
+
 static func _triple_quotes(line: String) -> int:
 	return line.count('"""') + line.count("'''")