gdharness 1.3.8 → 1.3.9

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

@@ -11,9 +11,6 @@ const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 const GdhSerialisation = preload("../serialisation.gd")
 
-## How far right of the rightmost state a new one goes in the editor's graph, wider than a state's
-## box there.
-const STATE_SPACING: float = 200.0
 const LOOP_MODES: Dictionary = {
 	"none": Animation.LOOP_NONE, "linear": Animation.LOOP_LINEAR, "pingpong": Animation.LOOP_PINGPONG
 }
@@ -335,6 +332,10 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	var track: Dictionary = given_track if given_track is Dictionary else {}
 	if track.is_empty():
 		return {"ok": false, "error": "Missing track"}
+	# The schema leaves keyframes out of what track requires, since remove_track finds a track without
+	# them.
+	if not track.has("keyframes"):
+		return {"ok": false, "error": "Missing track.keyframes"}
 	var keyed: Array = _keyframes(track)
 	if not keyed[0]:
 		return {"ok": false, "error": keyed[1]}
@@ -439,7 +440,15 @@ func _add_track(
 		method_found = target.has_method(method_name)
 		kind = Animation.TYPE_METHOD
 	else:
-		return [-1, "Unsupported track.type: " + track_type, null, false]
+		return [
+			-1,
+			(
+				"add_track makes property and method tracks, and track.type is %s; remove_track takes any."
+				% track_type
+			),
+			null,
+			false
+		]
 
 	var track_idx: int = anim.find_track(path, kind)
 	var existing: bool = track_idx >= 0
@@ -472,6 +481,98 @@ func _add_track(
 	return [track_idx, "", method_found, existing]
 
 
+## Takes out the track [code]track[/code] names by its type, nodePath and property as read answers
+## them, so a track read back can be passed as it stands; its keyframes are not looked at. Every
+## track of that shape goes, since the editor can make two for one path and both play.
+func remove_animation_track(args: Dictionary) -> Dictionary:
+	var scene_path: String = GdhSceneFile.res_path("", str(args.get("scenePath", "")))
+	var player_node_path: String = str(args.get("playerNodePath", "."))
+	var animation_name: String = str(args.get("animationName", ""))
+	var given_track: Variant = args.get("track", {})
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if animation_name.strip_edges().is_empty():
+		return {"ok": false, "error": "Missing animationName"}
+	var track: Dictionary = given_track if given_track is Dictionary else {}
+	if track.is_empty():
+		return {"ok": false, "error": "Missing track"}
+	var track_type: String = str(track.get("type", ""))
+	if not track_type in GdhAnimationReads.TRACK_TYPE_NAMES.values():
+		return {"ok": false, "error": "Unsupported track.type: " + track_type}
+	var node_path: String = str(track.get("nodePath", ""))
+	var property: String = str(track.get("property", ""))
+	var shape: Array = [track_type, node_path, property]
+
+	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
+	if found[1] == null:
+		return found[2]
+	var scene: GdhSceneFile = found[0]
+	var player: AnimationPlayer = found[1]
+	var anim: Animation = player.get_animation(StringName(animation_name))
+	var homes: Array = _homes(
+		scene, [[_library_of(player, animation_name), "animation library"], [anim, "animation"]]
+	)
+	if not homes[0]:
+		return scene.refuse(str(homes[1]))
+	var matching: Array[int] = []
+	var held: PackedStringArray = []
+	for index: int in anim.get_track_count():
+		var of: Array = _track_shape(anim, index)
+		if of == shape:
+			matching.append(index)
+		var _listed: bool = held.append("%s (%s)" % [str(anim.track_get_path(index)), of[0]])
+	if matching.is_empty():
+		var said: String = (
+			"%s has no %s track on %s"
+			% [
+				animation_name,
+				track_type,
+				node_path if property.is_empty() else "%s:%s" % [node_path, property]
+			]
+		)
+		if held.is_empty():
+			return scene.refuse("%s; it has no tracks." % said)
+		return scene.refuse("%s; its tracks are %s." % [said, ", ".join(held)])
+	var keys: int = 0
+	matching.reverse()
+	for index: int in matching:
+		keys += anim.track_get_key_count(index)
+		anim.remove_track(index)
+
+	var at: String = scene.path_of(player)
+	var left: int = anim.get_track_count()
+	var check: Callable = func(saved: Node) -> String:
+		var copy: AnimationPlayer = saved.get_node_or_null(at) as AnimationPlayer
+		if copy == null or not copy.has_animation(StringName(animation_name)):
+			return "%s would not be in the scene when it loads." % animation_name
+		if copy.get_animation(StringName(animation_name)).get_track_count() != left:
+			return "the track would still be in %s when the scene loads." % animation_name
+		return ""
+	var removed: Dictionary = {"type": track_type, "nodePath": node_path}
+	if not property.is_empty():
+		removed["property"] = property
+	var answer: Dictionary = {
+		"ok": true,
+		"animationName": animation_name,
+		"removed": removed,
+		"tracksRemoved": matching.size(),
+		"keysRemoved": keys,
+		"tracks": left,
+	}
+	var files: Dictionary = homes[1]
+	return _finish(scene, check, files, answer)
+
+
+## Track [param index] of [param anim] as [type, nodePath, property], named as read names them.
+static func _track_shape(anim: Animation, index: int) -> Array:
+	var path: NodePath = anim.track_get_path(index)
+	return [
+		GdhAnimationReads.TRACK_TYPE_NAMES.get(anim.track_get_type(index), str(anim.track_get_type(index))),
+		str(path.get_concatenated_names()),
+		str(path.get_concatenated_subnames()),
+	]
+
+
 ## The keys of [param anim], called [param animation_name], that lie past its end, where they never
 ## play, as a sentence naming each by its track's path and time, or "" when none does. The engine
 ## keeps such a key, as the editor does, so a longer length plays it again.
@@ -826,156 +927,3 @@ static func _collect_playing(
 	for step: String in children:
 		var child: AnimationNode = children[step]
 		_collect_playing(child, step if at.is_empty() else at + "/" + step, tree_path, animation_name, found)
-
-
-# =============================================================================
-# add_animation_state
-# =============================================================================
-func add_animation_state(args: Dictionary) -> Dictionary:
-	var scene_path: String = GdhSceneFile.res_path("", str(args.get("scenePath", "")))
-	var anim_tree_path: String = str(args.get("animTreePath", ""))
-	var state_name: String = str(args.get("stateName", ""))
-	var animation_name: String = str(args.get("animationName", ""))
-	var state_machine_path: String = str(args.get("stateMachinePath", ""))
-
-	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
-	for required: Array in [
-		[anim_tree_path, "animTreePath"], [state_name, "stateName"], [animation_name, "animationName"]
-	]:
-		if str(required[0]).is_empty():
-			return {"ok": false, "error": "Missing " + str(required[1])}
-
-	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: GdhSceneFile = opened[0]
-	if opened[1] == null:
-		return opened[2]
-	var anim_tree: AnimationTree = opened[1]
-	var machine: Array = _machine(scene, anim_tree, state_machine_path)
-	if machine[0] == null:
-		return scene.refuse(str(machine[2]))
-	var sm: AnimationNodeStateMachine = machine[0]
-	# add_node fails with nothing but a line in the editor's log on a name in use, and Start and End
-	# are in use in every state machine.
-	if sm.has_node(StringName(state_name)):
-		return scene.refuse("The state machine already has a state named %s." % state_name)
-	var player: AnimationPlayer = anim_tree.get_node_or_null(anim_tree.anim_player) as AnimationPlayer
-	var found: bool = player != null and player.has_animation(StringName(animation_name))
-
-	var anim_node: AnimationNodeAnimation = AnimationNodeAnimation.new()
-	anim_node.animation = StringName(animation_name)
-	# Beside the rightmost state: add_node puts a state at the origin, where the editor's graph
-	# draws it over whatever is already there, Start included.
-	var rightmost: Vector2 = Vector2.ZERO
-	for state: StringName in sm.get_node_list():
-		var held: Vector2 = sm.get_node_position(state)
-		if held.x > rightmost.x:
-			rightmost = held
-	var position: Vector2 = rightmost + Vector2(STATE_SPACING, 0)
-	sm.add_node(StringName(state_name), anim_node, position)
-	if not sm.has_node(StringName(state_name)):
-		return scene.refuse("The state machine did not take the state %s." % state_name)
-
-	var answer: Dictionary = {
-		"ok": true,
-		"stateName": state_name,
-		"animationName": animation_name,
-		# False when the tree has no player to look the animation up in, or its player has none of
-		# that name.
-		"animationFound": found,
-		"position": GdhSerialisation.new().serialize_value(position),
-	}
-	# Written all the same, as the editor writes one: a state machine is often laid out before its
-	# animations are made, and refusing it stopped a tree being built in that order.
-	if player != null and not found:
-		answer["animationMissing"] = _missing_animation(scene, player, animation_name)
-	var files: Dictionary = machine[1]
-	return _finish(scene, Callable(), files, answer)
-
-
-## Why the state playing [param animation_name] plays nothing yet. The player is named by its path
-## from the scene root, as playerNodePath takes it; anim_player is relative to the tree ("../Anim"),
-## which no argument takes.
-static func _missing_animation(
-	scene: GdhSceneFile, player: AnimationPlayer, animation_name: String
-) -> String:
-	var said: String = (
-		"The AnimationPlayer at %s has no animation %s yet, so the state plays nothing until it has one."
-		% [str(scene.root.get_path_to(player)), animation_name]
-	)
-	var close: PackedStringArray = GdhRead.nearest(animation_name, player.get_animation_list())
-	if close.is_empty():
-		return said
-	return (
-		said + " The nearest %s %s." % ["it has is" if close.size() == 1 else "it has are", ", ".join(close)]
-	)
-
-
-# =============================================================================
-# connect_animation_states
-# =============================================================================
-func connect_animation_states(args: Dictionary) -> Dictionary:
-	var scene_path: String = GdhSceneFile.res_path("", str(args.get("scenePath", "")))
-	var anim_tree_path: String = str(args.get("animTreePath", ""))
-	var from_state: String = str(args.get("fromState", ""))
-	var to_state: String = str(args.get("toState", ""))
-	var transition_type: String = str(args.get("transitionType", "immediate"))
-	var state_machine_path: String = str(args.get("stateMachinePath", ""))
-	var advance_condition: String = str(args.get("advanceCondition", ""))
-
-	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
-	if anim_tree_path.is_empty():
-		return {"ok": false, "error": "Missing animTreePath"}
-	if from_state.is_empty() or to_state.is_empty():
-		return {"ok": false, "error": "Missing fromState or toState"}
-	var modes: Dictionary = {
-		"sync": AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC,
-		"at_end": AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END,
-		"immediate": AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE,
-	}
-	if not modes.has(transition_type):
-		return {"ok": false, "error": "Unsupported transitionType: " + transition_type}
-	var transition: AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition.new()
-	transition.switch_mode = (
-		GdhRead.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
-	)
-	if not advance_condition.is_empty():
-		transition.advance_condition = StringName(advance_condition)
-
-	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: GdhSceneFile = opened[0]
-	if opened[1] == null:
-		return opened[2]
-	var anim_tree: AnimationTree = opened[1]
-	var machine: Array = _machine(scene, anim_tree, state_machine_path)
-	if machine[0] == null:
-		return scene.refuse(str(machine[2]))
-	var sm: AnimationNodeStateMachine = machine[0]
-	var problem: String = _transition_problem(sm, from_state, to_state)
-	if not problem.is_empty():
-		return scene.refuse(problem)
-
-	sm.add_transition(StringName(from_state), StringName(to_state), transition)
-	if not sm.has_transition(StringName(from_state), StringName(to_state)):
-		return scene.refuse("The state machine did not take the transition.")
-	var files: Dictionary = machine[1]
-	return _finish(scene, Callable(), files, {"ok": true, "from": from_state, "to": to_state})
-
-
-## Why [param sm] cannot take a transition from [param from_state] to [param to_state], or "".
-## Each is a condition add_transition fails on with only a line in the editor's log, and the
-## transition was answered as made.
-func _transition_problem(sm: AnimationNodeStateMachine, from_state: String, to_state: String) -> String:
-	for state: String in [from_state, to_state]:
-		if not sm.has_node(StringName(state)):
-			return "The state machine has no state named %s." % state
-	if from_state == to_state:
-		return "A transition needs two different states."
-	if from_state == "End":
-		return "No transition can leave End."
-	if to_state == "Start":
-		return "No transition can arrive at Start."
-	if sm.has_transition(StringName(from_state), StringName(to_state)):
-		return "There is already a transition from %s to %s." % [from_state, to_state]
-	return ""

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

@@ -9,6 +9,7 @@ const GdhPropertyValues = preload("../property_values.gd")
 const GdhRead = preload("../reading.gd")
 const GdhSame = preload("../same_values.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSerialisation = preload("../serialisation.gd")
 
 # The minimal shader of a type: its declaration and the one function the engine calls for it.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -25,6 +26,7 @@ const CELLS_SHOWN: int = 1000
 
 var _editor_plugin: EditorPlugin = null
 var _properties: GdhPropertyValues = GdhPropertyValues.new()
+var _values: GdhSerialisation = GdhSerialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -257,6 +259,8 @@ 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}
+	if not properties.is_empty():
+		answer["properties"] = _held(resource, properties.keys())
 	return answer
 
 
@@ -307,9 +311,20 @@ 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}
+	answer["properties"] = _held(resource, properties.keys())
 	return answer
 
 
+## What [param resource] holds at each property or path in [param asked], once the save has been
+## checked against it: a write saying only that it was written left the caller a second call to
+## learn what the engine kept.
+func _held(resource: Resource, asked: Array) -> Dictionary:
+	var held: Dictionary = {}
+	for key: Variant in asked:
+		held[str(key)] = _values.serialize_value(_properties.read_at(resource, str(key)))
+	return held
+
+
 ## What a resource file holds, read as a headless engine reads it with no editor connected.
 func read_resource(args: Dictionary) -> Dictionary:
 	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
@@ -649,7 +664,16 @@ func _tile_node(scene: GdhSceneFile, node_path: String, layer: int) -> Array:
 		return [null, "%s has %d layers, and no layer %d" % [node_path, layered.get_layers_count(), layer]]
 	var tile_set: TileSet = layered.tile_set if layered != null else single.tile_set
 	if tile_set == null:
-		return [null, "%s has no TileSet, so no cell can name a source" % node_path]
+		return [
+			null,
+			(
+				(
+					'%s has no TileSet, so no cell can name a source. scene_node set with properties {"tile_set": '
+					+ '"res://..."} on %s gives it one, a TileSet file such as resource_edit create_tileset makes.'
+				)
+				% [node_path, node_path]
+			)
+		]
 	return [node, ""]
 
 

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

@@ -118,13 +118,16 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 			"%s did not load back as a scene inheriting %s, so it was removed." % [scene_path, base_path]
 		}
 	GdhSceneFile.refresh(scene_path)
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"scenePath": scene_path,
 		"inherits": base_path,
 		"rootNodeType": root_type,
 		"rootNodeName": name
 	}
+	if script != null:
+		answer["script"] = script.resource_path
+	return answer
 
 
 ## Makes the children of [param node], an instance in [param scene], editable or not, answering why

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

@@ -171,6 +171,16 @@ static func place(node: Node, asked: Variant) -> void:
 		node.get_parent().move_child(node, GdhRead.as_int(asked))
 
 
+## Whether [param basis] has axes that are not at right angles, which a node kept in place under a
+## parent scaled unevenly across its turn ends up with. A Node2D says so through skew; a Node3D has
+## no property for it, and its position, rotation and scale read as if the axes were square.
+static func sheared(basis: Basis) -> bool:
+	var x: Vector3 = basis.x.normalized()
+	var y: Vector3 = basis.y.normalized()
+	var z: Vector3 = basis.z.normalized()
+	return absf(x.dot(y)) > 0.0001 or absf(x.dot(z)) > 0.0001 or absf(y.dot(z)) > 0.0001
+
+
 ## The properties that hold where [param node] is drawn, which a reparent keeping it in place
 ## changes: a Control keeps only its position, as Node.reparent keeps it.
 static func placing(node: Node) -> Array[String]:

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

@@ -204,6 +204,8 @@ func _create_of_a_class(args: Dictionary) -> Dictionary:
 	var answer: Dictionary = {
 		"ok": true, "scenePath": scene_path, "rootNodeType": asked_type, "rootNodeName": root_node_name
 	}
+	if not script_path.is_empty():
+		answer["script"] = script_path
 	if not had_folder:
 		answer["madeFolder"] = scene_path.get_base_dir()
 	return answer
@@ -299,6 +301,11 @@ func add_node(args: Dictionary) -> Dictionary:
 		"nodePath": new_path,
 		"index": new_node.get_index(),
 	}
+	if not properties.is_empty():
+		var held: Dictionary = {}
+		for key: Variant in properties:
+			held[str(key)] = _readable(new_node, _properties.read_at(new_node, str(key)))
+		answer["properties"] = held
 	_properties.note_write(answer, new_node)
 	if not adding.is_empty():
 		answer.merge(GdhGroups.read(scene, new_node))
@@ -503,6 +510,7 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	var drawn_at: 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
 	# 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
@@ -517,6 +525,20 @@ func reparent_node(args: Dictionary) -> Dictionary:
 		var now: Variant = _properties.read_at(node, property)
 		if not GdhSame.same(now, drawn_at[property]):
 			also_changed[property] = {"was": _readable(node, drawn_at[property]), "now": _readable(node, now)}
+	var sheared: String = ""
+	if node is Node3D and GdhPlacing.sheared((node as Node3D).basis):
+		var spatial: Node3D = node
+		also_changed["transform"] = {
+			"was": _readable(node, held_at), "now": _readable(node, spatial.transform)
+		}
+		sheared = (
+			(
+				"%s keeps where it is drawn under %s, which is scaled unevenly across the way it is turned,"
+				+ " so its basis is sheared: no position, rotation and scale describe it, and transform is"
+				+ " what it holds. keepGlobalTransform false keeps its own transform instead."
+			)
+			% [str(node.name), new_parent_path]
+		)
 
 	var new_path: String = scene.path_of(node)
 	var index: int = node.get_index()
@@ -546,6 +568,8 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	}
 	if not also_changed.is_empty():
 		answer["alsoChanged"] = also_changed
+	if not sheared.is_empty():
+		answer["sheared"] = sheared
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
@@ -571,9 +595,8 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var node: Node = GdhSceneFile.node_at(scene.root, node_path)
 	if not node:
 		return scene.refuse(scene.not_found("Node not found: " + node_path, node_path))
-	var foreign: String = scene.foreign(node)
-	if not foreign.is_empty():
-		return scene.refuse(foreign)
+	# A rename is refused for the scene that makes the node before anything else, since editable
+	# children would let this scene keep values on it and still never rename it.
 	if properties.has("name") and node != scene.root:
 		var fixed: String = scene.fixed(node)
 		if not fixed.is_empty():
@@ -581,6 +604,9 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		var unusable: String = scene.unusable_name(node.get_parent(), str(properties["name"]), node)
 		if not unusable.is_empty():
 			return scene.refuse(unusable)
+	var foreign: String = scene.foreign(node)
+	if not foreign.is_empty():
+		return scene.refuse(foreign)
 
 	var dropped: Dictionary = {}
 	if editable != null:
@@ -607,6 +633,12 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	_properties.note_write(answer, node)
 	if not adding.is_empty() or not removing.is_empty():
 		answer["groups"] = GdhGroups.read(scene, node).get("groups", [])
+	var named: Array[String] = []
+	for key: Variant in properties:
+		var property: String = str(key).get_slice(":", 0)
+		if property != "name" and property in node and not named.has(property):
+			named.append(property)
+	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 written: Dictionary = scene.write(
@@ -630,11 +662,48 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	if not dropped.is_empty():
 		answer["droppedValues"] = dropped["values"]
 		answer["droppedNodes"] = dropped["nodes"]
+	_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
 
 
+## 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.
+static func _note_left_out(
+	answer: Dictionary, pack: PackedScene, at: String, named: Array[String], source: String
+) -> void:
+	var stored: Dictionary = {}
+	var state: SceneState = pack.get_state()
+	for index: int in state.get_node_count():
+		if str(state.get_node_path(index)).trim_prefix("./") == at:
+			for property: int in state.get_node_property_count(index):
+				stored[str(state.get_node_property_name(index, property))] = true
+	var left: Array[String] = []
+	for asked: String in named:
+		if not stored.has(asked):
+			left.append(asked)
+	if left.is_empty():
+		return
+	answer["notStored"] = left
+	var names: String = ", ".join(left)
+	var verb: String = "holds" if left.size() == 1 else "hold"
+	var pronoun: String = "it" if left.size() == 1 else "them"
+	if source.is_empty():
+		answer["notStoredNote"] = (
+			"%s now %s the default, so the file does not store %s." % [names, verb, pronoun]
+		)
+	else:
+		answer["notStoredNote"] = (
+			(
+				"%s now %s what %s gives this node, so the file does not store %s, and a change there reaches "
+				+ "this node."
+			)
+			% [names, verb, source, pronoun]
+		)
+
+
 func get_node_properties(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))

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

@@ -265,8 +265,14 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	# 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:
+		# The root's path is ".", which before ".method" read as "..method".
+		var said_from: String = str(source.name) if source == scene.root else from
+		var said_to: String = str(target.name) if target == scene.root else to
 		return scene.refuse(
-			"%s has no connection from %s.%s to %s.%s." % [scene_path, from, signal_name, to, method_name]
+			(
+				"%s has no connection from %s.%s to %s.%s."
+				% [scene_path, said_from, signal_name, said_to, method_name]
+			)
 		)
 	source.disconnect(signal_name, Callable(target, method_name))
 

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

@@ -16,6 +16,10 @@ var refused: String = ""
 var raised: Array[String] = []
 ## The warnings reported while it ran, a line each.
 var warned: Array[String] = []
+## Where a script error first ended each function it ended, as "res://path:line" by function name.
+## A function the VM ends at a script error gives back its return type's default, 0, "" or null,
+## and its caller goes on with that as if it had been returned.
+var ended_at: Dictionary = {}
 
 
 func _log_message(_message: String, _error: bool) -> void:
@@ -26,8 +30,8 @@ func _log_message(_message: String, _error: bool) -> void:
 # gdlint:ignore = function-arguments-number
 func _log_error(
 	function: String,
-	_file: String,
-	_line: int,
+	file: String,
+	line: int,
 	code: String,
 	rationale: String,
 	_editor_notify: bool,
@@ -45,3 +49,5 @@ func _log_error(
 		warned.append(text)
 	else:
 		raised.append(text)
+	if error_type == ERROR_TYPE_SCRIPT and not ended_at.has(function):
+		ended_at[function] = "%s:%d" % [file, line]

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

@@ -24,6 +24,23 @@ extends RefCounted
 
 ## How many of a node's children a refusal for a path missing below it names.
 const NAMED_CHILDREN: int = 12
+## The types holding their floats as the engine's real numbers, 32-bit unless it was built for 64.
+const SHAPES_OF_REALS: Array[int] = [
+	TYPE_VECTOR2,
+	TYPE_VECTOR3,
+	TYPE_VECTOR4,
+	TYPE_RECT2,
+	TYPE_PLANE,
+	TYPE_QUATERNION,
+	TYPE_AABB,
+	TYPE_BASIS,
+	TYPE_TRANSFORM2D,
+	TYPE_TRANSFORM3D,
+	TYPE_PROJECTION,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+]
 
 
 static func as_int(value: Variant, fallback: int = 0) -> int:
@@ -190,18 +207,26 @@ static func offered(said: String, word: String, names: Array) -> String:
 
 
 ## [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.
+## names it declares nearest it when any are, as a misspelt one is usually one of them, or else the
+## variables its script declares. The engine's own are not listed when none is near, since an object
+## has a hundred, while a script's are the few a caller most likely meant.
 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] = []
+	var scripted: Array[String] = []
 	for declared: Dictionary in target.get_property_list():
-		if not as_int(declared.get("usage", 0)) & headings:
+		var usage: int = as_int(declared.get("usage", 0))
+		if not usage & headings:
 			names.append(str(declared.get("name", "")))
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE and not usage & headings:
+			scripted.append(str(declared.get("name", "")))
 	var close: PackedStringArray = nearest(property, PackedStringArray(names))
-	if close.is_empty():
+	if not close.is_empty():
+		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if scripted.is_empty():
 		return said
-	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	scripted.sort()
+	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(scripted))]
 
 
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
@@ -219,3 +244,34 @@ static func signals_of(object: Object) -> Array:
 ## [param word] after the article it takes, "an AnimationTree" or "a Node2D".
 static func with_article(word: String) -> String:
 	return ("an " if word.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + word
+
+
+## [param value], which the engine holds as a 32-bit float, as the shortest decimal that is still
+## that float. JSON carries a double, and the double a 32-bit 0.2 widens to is 0.200000002980232:
+## the same number, but not the one written or the one the file shows, so a caller comparing what it
+## set against what it read saw them differ. The shorter one, sent back, stores the same 32 bits. A
+## plain float is left alone by the serialiser, since nothing says whether the engine holds it in
+## 32 bits or 64.
+static func single(value: float) -> float:
+	if not is_finite(value) or value == 0.0:
+		return value
+	var held: float = PackedFloat32Array([value])[0]
+	var magnitude: int = floori(log(absf(held)) / log(10.0))
+	for digits: int in range(1, 10):
+		var shift: int = digits - 1 - magnitude
+		var tried: float = (
+			roundf(held * pow(10.0, shift)) / pow(10.0, shift)
+			if shift >= 0
+			else roundf(held / pow(10.0, -shift)) * pow(10.0, -shift)
+		)
+		if PackedFloat32Array([tried])[0] == held:
+			return tried
+	return held
+
+
+## Whether a value of [param type] holds its floats in 32 bits: a colour always, and the vectors and
+## the shapes built of them unless the engine was built for 64.
+static func holds_singles(type: int) -> bool:
+	if type in [TYPE_COLOR, TYPE_PACKED_COLOR_ARRAY, TYPE_PACKED_FLOAT32_ARRAY]:
+		return true
+	return not OS.has_feature("double") and type in SHAPES_OF_REALS