gdharness 1.3.8 → 1.3.10

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

@@ -22,6 +22,22 @@ static func read(scene: GdhSceneFile, node: Node) -> Dictionary:
 	return answer
 
 
+## The groups of [param node], just added to this scene and put in [param adding] there, in the shape
+## [method read] answers: this scene's file does not hold the node until it is saved.
+static func read_added(node: Node, adding: Array) -> Dictionary:
+	var all: Array = _sorted(node.get_groups())
+	if all.is_empty():
+		return {}
+	var answer: Dictionary = {"groups": all}
+	var here: Array = []
+	for group: String in _sorted(adding):
+		if not here.has(group):
+			here.append(group)
+	if here.size() != all.size():
+		answer["groupsHere"] = here
+	return answer
+
+
 ## The group names under [param key] of [param args], which the server has checked are strings, or
 ## none when not given.
 static func asked(args: Dictionary, key: String) -> Array:

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

@@ -7,6 +7,7 @@ extends RefCounted
 const GdhFileReads = preload("../file_reads.gd")
 const GdhPaths = preload("scene_paths.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneUids = preload("../scene_uids.gd")
 
 
 ## Why a create at [param scene_path] is refused when a file is there already, which saving over
@@ -87,14 +88,14 @@ static func inherit(scene_path: String, base_path: String, root_name: String, sc
 		"",
 		(
 			'[ext_resource type="PackedScene"%s path="%s" id="1_base"]'
-			% [GdhSceneFile.reference_uid(base_path), base_path]
+			% [GdhSceneUids.reference_uid(base_path), base_path]
 		),
 	]
 	if script != null:
 		var _resourced: bool = lines.append(
 			(
 				'[ext_resource type="Script"%s path="%s" id="2_script"]'
-				% [GdhSceneFile.reference_uid(script.resource_path), script.resource_path]
+				% [GdhSceneUids.reference_uid(script.resource_path), script.resource_path]
 			)
 		)
 	lines.append_array(["", '[node name="%s" instance=ExtResource("1_base")]' % name])
@@ -118,13 +119,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
@@ -176,7 +180,7 @@ static func follow(changed: String, old_path: String, new_path: String, carried:
 		var moves: Dictionary = {}
 		if _inherits(scene_path, changed, texts):
 			moves[old_path] = new_path
-		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false)
+		var read: Dictionary = GdhFileReads.scene_tree(scene_path, -1, false, false)
 		if not read.get("ok", false):
 			not_followed.append({"scenePath": scene_path, "reason": str(read.get("error", ""))})
 			continue

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

@@ -14,6 +14,7 @@ enum { UNCHANGED, REWRITTEN, DELETED }
 const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
+const GdhSceneUids = preload("../scene_uids.gd")
 ## PROPERTY_HINT_NO_NODEPATH, which marks a property the editor's rename skips. It is not bound for
 ## scripts, and follows PROPERTY_HINT_ONESHOT in the engine's list.
 const HINT_NO_NODEPATH: int = PROPERTY_HINT_ONESHOT + 1
@@ -127,7 +128,7 @@ func put_back(scene_path: String, why: String = "") -> void:
 func answer() -> Dictionary:
 	for file: String in _homes:
 		var resource: Resource = _homes[file]
-		var saving: Error = GdhSceneFile.save_keeping_uid(resource, file)
+		var saving: Error = GdhSceneUids.save_keeping_uid(resource, file)
 		if saving == OK:
 			if Engine.is_editor_hint():
 				EditorInterface.get_resource_filesystem().update_file(file)

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

@@ -3,17 +3,20 @@ extends Node
 
 ## Scenes and their nodes, edited in the open editor and read back from what it holds.
 
+const GdhDeclared = preload("../declared_values.gd")
 const GdhFileReads = preload("../file_reads.gd")
 const GdhRead = preload("../reading.gd")
 const GdhGroups = preload("scene_groups.gd")
+const GdhHeadlessCheck = preload("../headless_check.gd")
 const GdhKin = preload("scene_kin.gd")
+const GdhNavigationBake = preload("navigation_bake.gd")
 const GdhPaths = preload("scene_paths.gd")
 const GdhPlacing = preload("scene_placing.gd")
 const GdhPropertyValues = preload("../property_values.gd")
-const GdhResourceTools = preload("resource_tools.gd")
 const GdhSame = preload("../same_values.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 const GdhSerialisation = preload("../serialisation.gd")
+const GdhTilesetTools = preload("tileset_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 var _values: GdhSerialisation = GdhSerialisation.new()
@@ -204,6 +207,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
@@ -214,10 +219,11 @@ func list_scene_nodes(args: Dictionary) -> Dictionary:
 	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
 	var depth: int = GdhRead.as_int(args.get("depth", -1), -1)
 	var include_properties: bool = GdhRead.as_bool(args.get("includeProperties", false))
+	var include_defaults: bool = GdhRead.as_bool(args.get("includeDefaults", false))
 
 	# Read as a headless engine reads it with no editor connected, so the answer does not depend on
 	# whether one is.
-	var read: Dictionary = GdhFileReads.scene_tree(scene_path, depth, include_properties)
+	var read: Dictionary = GdhFileReads.scene_tree(scene_path, depth, include_properties, include_defaults)
 	if read.get("ok", false):
 		read["unsavedInEditor"] = GdhSceneFile.unsaved(scene_path)
 	return read
@@ -285,6 +291,9 @@ func add_node(args: Dictionary) -> Dictionary:
 		return scene.refuse("Nothing was written: " + unsettled)
 	scene.asked(new_node, properties.keys())
 	var unwritten: String = _properties.write_all(new_node, properties)
+	scene.asked(new_node, _properties.moved_by_engine.keys())
+	if not unwritten.is_empty():
+		unwritten = GdhHeadlessCheck.setter_ran(new_node, _properties.unheld, unwritten)
 	if unwritten.is_empty():
 		unwritten = GdhGroups.change(scene, new_node, adding, [])
 	if not unwritten.is_empty():
@@ -299,9 +308,14 @@ 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))
+		answer.merge(GdhGroups.read_added(new_node, adding))
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String:
 			var unkept: String = _kept(
@@ -503,6 +517,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 +532,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 +575,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 +602,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 +611,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:
@@ -593,8 +626,13 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 	var old_path: String = scene.path_of(node)
 	scene.asked(node, properties.keys())
 	var refused_property: String = _properties.write_all(node, properties)
+	scene.asked(node, _properties.moved_by_engine.keys())
 	if not refused_property.is_empty():
-		return scene.refuse(GdhSceneFile.missing_on(node, refused_property))
+		return scene.refuse(
+			GdhHeadlessCheck.setter_ran(
+				node, _properties.unheld, GdhSceneFile.missing_on(node, refused_property)
+			)
+		)
 	var ungrouped: String = GdhGroups.change(scene, node, adding, removing)
 	if not ungrouped.is_empty():
 		return scene.refuse(ungrouped)
@@ -607,6 +645,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 +674,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", "")))
@@ -657,11 +738,55 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# names this scene's file sets are always answered.
 	var set_here: Dictionary = scene.set_here(node)
 	var props: Dictionary = _properties_of(node, include_defaults, set_here)
-	var cells: Dictionary = GdhResourceTools.cells_of(node)
+	var cells: Dictionary = GdhTilesetTools.cells_of(node)
 	var at: String = scene.path_of(node)
 	var here: Array = set_here.keys()
 	here.sort()
 	var answer: Dictionary = {"ok": true, "nodePath": at, "properties": props, "setHere": here}
+	# A Node3D stores only its transform, a matrix, while a set takes the position, rotation and
+	# scale the inspector shows, so a node turned 45 degrees down read back as nine numbers. A
+	# sheared one has no such three, and is left to its transform.
+	var placed: Node3D = node as Node3D
+	var rebuilt: Transform3D = Transform3D()
+	if placed != null:
+		var turned: Basis = Basis.from_euler(placed.rotation, placed.rotation_order)
+		rebuilt = Transform3D(turned * Basis.from_scale(placed.scale), placed.position)
+	if placed != null and props.has("transform") and rebuilt.is_equal_approx(placed.transform):
+		# Rounded, since a node never scaled came back with a scale of 0.99999994 out of the matrix;
+		# the transform beside it is exact.
+		var step: Vector3 = Vector3.ONE * 0.00001
+		answer["placement"] = {
+			"position": _readable(node, placed.position.snapped(step)),
+			"rotation_degrees": _readable(node, placed.rotation_degrees.snapped(step)),
+			"scale": _readable(node, placed.scale.snapped(step)),
+		}
+	# A player's getter answers Master for a bus the layout does not have, while the file keeps the
+	# name, so a player left on a renamed or removed bus read as one put on Master.
+	var bus: String = str(set_here.get("bus", ""))
+	var plays: bool = node is AudioStreamPlayer or node is AudioStreamPlayer2D or node is AudioStreamPlayer3D
+	if plays and not bus.is_empty() and AudioServer.get_bus_index(bus) == -1:
+		props["bus"] = bus
+		var buses: PackedStringArray = []
+		for index: int in AudioServer.bus_count:
+			var _added: bool = buses.append(AudioServer.get_bus_name(index))
+		answer["busNote"] = (
+			(
+				"%s names the bus %s, which the project's bus layout does not have, so it plays on %s; "
+				+ "the buses are %s."
+			)
+			% [str(node.name) if at == "." else at, bus, AudioServer.get_bus_name(0), ", ".join(buses)]
+		)
+	# A mask reads as a number, and which layers it holds, under the names the project gives them,
+	# is what a caller reads it for.
+	var layers: Dictionary = {}
+	for declared: Dictionary in node.get_property_list():
+		var hint: int = GdhRead.as_int(declared.get("hint", PROPERTY_HINT_NONE))
+		var named: String = str(declared.get("name", ""))
+		var mask: Variant = node.get(named) if props.has(named) else null
+		if hint in GdhDeclared.LAYER_NAMES and mask is int:
+			layers[named] = GdhDeclared.layers_in(hint, GdhRead.as_int(mask))
+	if not layers.is_empty():
+		answer["layers"] = layers
 	answer.merge(GdhSceneFile.class_of(node))
 	answer.merge(GdhGroups.read(scene, node))
 	var from: String = scene.values_from(node, at)
@@ -684,6 +809,24 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	return answer
 
 
+func bake_navigation(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 node_path: String = str(args.get("nodePath", "."))
+	var opened: Array = _open(scene_path, true)
+	var scene: GdhSceneFile = opened[0]
+	var refused: Dictionary = opened[1]
+	if not refused.is_empty():
+		return refused
+	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)
+	return GdhNavigationBake.bake(scene, node)
+
+
 func save_scene(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/settings_tools.gd

@@ -10,12 +10,12 @@ extends Node
 ## of the two a caller wants is theirs to say, so the server only comes here when asked, and the
 ## difference is the reason the argument exists rather than an inconvenience to paper over.
 ##
-## Every value goes through the same serialiser the headless answer uses, because the two are one
+## Every answer is built by the same reads the headless answer uses, because the two are one
 ## question asked of two places: a value spelled differently here would read as the editor and the
 ## file disagreeing about something they agree about.
 
-const GdhRead = preload("../reading.gd")
 const GdhSerialisation = preload("../serialisation.gd")
+const GdhSettingReads = preload("../setting_reads.gd")
 
 var _values: GdhSerialisation = GdhSerialisation.new()
 
@@ -23,42 +23,19 @@ var _values: GdhSerialisation = GdhSerialisation.new()
 func get_project_setting(args: Dictionary) -> Dictionary:
 	var prefix: String = str(args.get("prefix", ""))
 	if not prefix.is_empty():
-		return _settings_under(prefix)
+		var family: Dictionary = GdhSettingReads.under(prefix, _values)
+		family["ok"] = true
+		return family
 
 	var setting: String = str(args.get("setting", ""))
 	if setting.is_empty():
 		return {"ok": false, "error": "setting is required, or prefix to read every setting under one"}
 
-	var exists: bool = ProjectSettings.has_setting(setting)
-	var result: Dictionary = {"ok": true, "setting_path": setting, "exists": exists, "value": null}
-	if exists:
-		result["value"] = _values.serialize_value(ProjectSettings.get_setting(setting))
-	else:
-		result["message"] = "Setting does not exist"
+	var result: Dictionary = GdhSettingReads.one(setting, _values)
+	result["ok"] = true
 	return result
 
 
-## Every setting under [prefix] with the type the engine registers for each, which is the half a
-## name hides: a family of levels can hold a setting that is a bool, and writing a level over it
-## looks like it worked.
-func _settings_under(prefix: String) -> Dictionary:
-	var found: Array[Dictionary] = []
-	for property: Dictionary in ProjectSettings.get_property_list():
-		var setting: String = str(property.get("name", ""))
-		if not setting.begins_with(prefix):
-			continue
-		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
-		var described: Dictionary = {
-			"setting": setting,
-			"type": type_string(kind),
-			"value": _values.serialize_value(ProjectSettings.get_setting(setting)),
-		}
-		found.append(described)
-
-	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
-	return {"ok": true, "prefix": prefix, "count": found.size(), "settings": found}
-
-
 ## Takes the named settings from project.godot as it is on disk, after something else wrote it.
 ##
 ## The editor loads the file once, at startup. Written from outside, it goes on holding the old