gdharness 1.2.29 → 1.2.31

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

@@ -5,6 +5,7 @@ extends Node
 
 const Read = preload("../reading.gd")
 const PropertyValues = preload("../property_values.gd")
+const ResourceTools = preload("resource_tools.gd")
 const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
@@ -101,8 +102,8 @@ func _kept(scene: SceneFile, saved: Node, node: Node, names: Array) -> String:
 		return "%s is not in the scene as it would be saved." % at
 	for key: Variant in names:
 		var property: String = str(key)
-		var loaded: Variant = copy.get(property)
-		if not scene.kept(saved, loaded, node.get(property)):
+		var loaded: Variant = _properties.read_at(copy, property)
+		if not scene.kept(saved, loaded, _properties.read_at(node, property)):
 			return (
 				(
 					"%s.%s would load from the file as %s: the scene does not keep it, because the property "
@@ -601,7 +602,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 
 	var held: Dictionary = {}
 	for key: Variant in properties:
-		held[str(key)] = _readable(node, node.get(str(key)))
+		held[str(key)] = _readable(node, _properties.read_at(node, str(key)))
 	var new_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(
 		func(saved: Node) -> String: return _kept(scene, saved, node, properties.keys())
@@ -633,6 +634,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# variable read as changed; and a value this scene sets back to the default was hidden, so the
 	# names this scene's file sets are always answered.
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
+	var cells: Dictionary = ResourceTools.cells_of(node)
 	scene.close()
 	var answer: Dictionary = {
 		"ok": true,
@@ -640,6 +642,7 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 		"properties": props,
 		"unsavedInEditor": SceneFile.unsaved(scene_path)
 	}
+	answer.merge(cells)
 	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
 	if props.is_empty() and not include_defaults:
 		answer["note"] = (
@@ -757,6 +760,10 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	# asked for. Left alone, the answer gave the flags asked for and the file kept the old ones.
 	var callable: Callable = Callable(target, method_name)
 	var method_found: bool = target.has_method(method_name)
+	var flags_before: int = -1
+	for connection: Dictionary in source.get_signal_connection_list(signal_name):
+		if connection.get("callable") == callable:
+			flags_before = Read.as_int(connection.get("flags", 0))
 	if source.is_connected(signal_name, callable):
 		source.disconnect(signal_name, callable)
 	var connect_result: Error = source.connect(signal_name, callable, flags)
@@ -776,7 +783,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"sourceNodePath": from,
 		"signalName": signal_name,
@@ -788,6 +795,14 @@ func connect_signal(args: Dictionary) -> Dictionary:
 		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
 		"methodFound": method_found
 	}
+	# A second connect of the same pair read exactly like the first, so a caller could not tell a
+	# connection made from one that was already there, and a list showing one where two were made
+	# looked like a lost write.
+	if flags_before >= 0:
+		answer["alreadyConnected"] = true
+		if flags_before != Read.as_int(saved_flags[0]):
+			answer["flagsBefore"] = _flag_names(flags_before)
+	return answer
 
 
 ## The two ends of a connection in [param scene], as [source, target], or [null, why not].

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

@@ -61,65 +61,13 @@ func set_property(params: Dictionary) -> Dictionary:
 	if not Paths.can_read(holder, named):
 		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
 	var old_value: Variant = Paths.read_under(holder, named)
-	# The same rule the call path holds: a value that cannot become what the property holds is
-	# refused rather than written. Writing it means the engine picks something, and what it picks
-	# for a word where a number goes is zero, which the answer then reports as the new value.
-	#
-	# A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
-	# anything, and the engine stores what it is given there. What it holds now still says how a value
-	# of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
-	# a value of another kind is stored as sent: a word into one holding a number is the word, and a
-	# number into one holding a word is the number, not its text. The text null empties it when it
-	# holds an object or nothing, as a wait reads it on the same slot.
 	var slot: Dictionary = Values.slot_declared(holder, named)
 	var declared: int = slot["type"]
 	var declared_script: Script = slot["script"]
-	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
-	var holds_objects: bool = (
-		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
-	)
-	var given: Variant
-	if holds_objects and names_no_object(value):
-		given = null
-	elif wanted == TYPE_OBJECT and (value is String or value is Dictionary):
-		var named_object: Dictionary = _object_named(
-			node, node_path, value, str(slot["class"]), declared_script
-		)
-		if named_object.has("message"):
-			return {
-				"type": "error",
-				"message": "%s.%s holds an object: %s" % [reached["called"], named, named_object["message"]]
-			}
-		given = named_object["object"]
-	else:
-		var as_sent: Variant = _values.fitted(value, TYPE_NIL)
-		if declared == TYPE_NIL and not Values.acceptable(as_sent, wanted):
-			given = as_sent
-		else:
-			given = _values.fitted(value, wanted)
-			if not Values.acceptable(given, wanted):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s holds %s and the value given is %s, which cannot become one.%s"
-						% [
-							reached["called"],
-							named,
-							type_string(wanted),
-							type_string(typeof(given)),
-							_written_as(wanted)
-						]
-					)
-				}
-		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
-		if typed.has("message"):
-			return {
-				"type": "error",
-				"message":
-				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
-			}
-		given = typed["value"]
+	var fitting: Dictionary = _value_for(value, slot, old_value, reached, node, node_path)
+	if fitting.has("message"):
+		return fitting
+	var given: Variant = fitting["value"]
 	# A component of a vector or a transform is written into a copy, which is put back where it was
 	# read from, setter and all; the read back is then taken off the game again, since the copy here
 	# says only what was written into it.
@@ -201,6 +149,131 @@ func set_property(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## What [param sent] becomes as argument [param index] of the method [param named] on the holder
+## [param reached] ends at, as [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal
+## saying why it cannot become one: a number the parameter would have to cut, a value that cannot be
+## converted, or a list or map that cannot be built as the typed one the parameter takes.
+func _argument_for(
+	sent: Variant, index: int, reached: Dictionary, named: String, node: Node, node_path: String
+) -> Dictionary:
+	var holder: Object = reached["holder"]
+	var called: String = reached["called"]
+	var wants: int = _values.parameter_type(holder, named, index)
+	if Values.cuts(sent, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which it would have to be cut to fit"
+				% [called, named, type_string(wants), index + 1, JSON.stringify(sent)]
+			)
+		}
+	var given: Variant = _values.fitted(sent, wants)
+	if not Values.acceptable(given, wants):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
+				% [
+					called,
+					named,
+					type_string(wants),
+					index + 1,
+					type_string(typeof(given)),
+					_written_as(wants)
+				]
+			)
+		}
+	# A typed list or map is built as one, since a plain one handed to such a parameter raises
+	# inside the game, which is what every check here exists to stop.
+	var container: Variant = _values.parameter_container(holder, named, index)
+	if container == null:
+		return {"value": given}
+	var typed: Dictionary = _values.typed_like(given, container, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s takes a typed %s as argument %d: %s."
+				% [called, named, _sort_of(container), index + 1, typed["message"]]
+			)
+		}
+	return {"value": typed["value"]}
+
+
+## What [param value] becomes written into the slot [param reached] ends on, as
+## [method Paths.walk_to] answered it, as `{"value": ...}`, or the refusal saying why it cannot become
+## one.
+##
+## The same rule the call path holds: a value that cannot become what the property holds is
+## refused rather than written. Writing it means the engine picks something, and what it picks
+## for a word where a number goes is zero, which the answer then reports as the new value. So is a
+## number a whole number or a truth would have to cut, since converting one truncates.
+##
+## A slot declaring nothing, an untyped or Variant property or an element of an untyped list, takes
+## anything, and the engine stores what it is given there. What it holds now still says how a value
+## of the same kind is meant, 5 into an int staying an int, and whether a path names an object, but
+## a value of another kind is stored as sent: a word into one holding a number is the word, a
+## fraction into one holding a whole number is the fraction, and a number into one holding a word is
+## the number, not its text. The text null empties it when it holds an object or nothing, as a wait
+## reads it on the same slot.
+func _value_for(
+	value: Variant, slot: Dictionary, old_value: Variant, reached: Dictionary, node: Node, node_path: String
+) -> Dictionary:
+	var named: String = reached["name"]
+	var called: String = reached["called"]
+	var declared: int = slot["type"]
+	var declared_script: Script = slot["script"]
+	var wanted: int = declared if declared != TYPE_NIL else typeof(old_value)
+	var holds_objects: bool = (
+		declared == TYPE_OBJECT or (declared == TYPE_NIL and (old_value == null or old_value is Object))
+	)
+	if holds_objects and names_no_object(value):
+		return {"value": null}
+	if wanted == TYPE_OBJECT and (value is String or value is Dictionary):
+		var named_object: Dictionary = _object_named(
+			node, node_path, value, str(slot["class"]), declared_script
+		)
+		if named_object.has("message"):
+			return {
+				"type": "error",
+				"message": "%s.%s holds an object: %s" % [called, named, named_object["message"]]
+			}
+		return {"value": named_object["object"]}
+	var as_sent: Variant = _values.fitted(value, TYPE_NIL)
+	var cut: bool = Values.cuts(value, wanted)
+	var given: Variant = as_sent
+	if declared != TYPE_NIL and cut:
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s.%s holds %s and the value given is %s, which it would have to be cut to fit"
+				% [called, named, type_string(wanted), JSON.stringify(value)]
+			)
+		}
+	if declared != TYPE_NIL or (not cut and Values.acceptable(as_sent, wanted)):
+		given = _values.fitted(value, wanted)
+		if not Values.acceptable(given, wanted):
+			return {
+				"type": "error",
+				"message":
+				(
+					"%s.%s holds %s and the value given is %s, which cannot become one.%s"
+					% [called, named, type_string(wanted), type_string(typeof(given)), _written_as(wanted)]
+				)
+			}
+	var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
+	if typed.has("message"):
+		return {
+			"type": "error",
+			"message": "%s.%s is a typed %s: %s." % [called, named, _sort_of(old_value), typed["message"]]
+		}
+	return {"value": typed["value"]}
+
+
 ## Whether [param given] is the value [param held] already is, at the precision the property keeps.
 ##
 ## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
@@ -254,6 +327,12 @@ func call_method(params: Dictionary) -> Dictionary:
 		var spelled: String = str(reached["name"])
 		if Paths.method_of(spelled).is_empty():
 			spelled += "()"
+		# A vector or a transform has no element to call a method on: it is read by its components.
+		if Paths.composite(reached["holder"]):
+			return {
+				"type": "error",
+				"message": Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
+			}
 		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
 			var read_from: int = Time.get_ticks_usec()
 			var answered: Variant = Paths.read_under(reached["holder"], spelled)
@@ -320,41 +399,10 @@ func call_method(params: Dictionary) -> Dictionary:
 				by_engine_class[index + 1] = [declared, Values.class_of(resolved)]
 			deserialized_args.append(named_object["object"])
 			continue
-		var given: Variant = _values.fitted(args[index], wants)
-		if not Values.acceptable(given, wants):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted.%s"
-					% [
-						reached["called"],
-						named,
-						type_string(wants),
-						index + 1,
-						type_string(typeof(given)),
-						_written_as(wants)
-					]
-				)
-			}
-		# A typed list or map is built as one, since a plain one handed to such a parameter raises
-		# inside the game, which is what every check here exists to stop.
-		var container: Variant = _values.parameter_container(holder, named, index)
-		if container != null:
-			var typed: Dictionary = _values.typed_like(
-				given, container, _element_object.bind(node, node_path)
-			)
-			if typed.has("message"):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s takes a typed %s as argument %d: %s."
-						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
-					)
-				}
-			given = typed["value"]
-		deserialized_args.append(given)
+		var argument: Dictionary = _argument_for(args[index], index, reached, named, node, node_path)
+		if argument.has("message"):
+			return argument
+		deserialized_args.append(argument["value"])
 
 	# Timed around the call alone, since the bridge's round trip is a second or more and swamps what
 	# one click's work costs; the frame metrics read whichever frame is last, which is not this one.

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

@@ -4,6 +4,7 @@ extends RefCounted
 ## run off the game the node keeps. Every op that reads, writes, calls or waits on a game's state
 ## walks the same way, so the walk and what it says when a step is not there live in one place.
 
+const Serialisation = preload("serialisation.gd")
 const Values = preload("runtime_values.gd")
 
 ## The calls a path makes on a list or a map: those that take no arguments and change nothing.
@@ -95,7 +96,7 @@ const READS_ONLY: String = ", and a path, which a wait reads every frame, only c
 ##
 ## A step into a vector, a colour, a rectangle or a transform reads one of its components,
 ## "size:x" or "global_transform:origin:y", by the names GDScript gives them; see
-## [method Values.components_of].
+## [method Serialisation.components_of].
 ##
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
@@ -184,7 +185,7 @@ static func can_hold(value: Variant) -> bool:
 ## Whether [param value] is read by its components, a vector or a colour or a transform, and is a
 ## copy wherever it is read from.
 static func composite(value: Variant) -> bool:
-	return not Values.components_of(value).is_empty()
+	return not Serialisation.components_of(value).is_empty()
 
 
 ## Whether [param value] is a packed list. Stepped into the way a list is, by index, and a write into
@@ -234,7 +235,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 			return args.is_empty() and method in MAP_CALLS
 		return not _key_in(map, named).is_empty()
 	if composite(holder):
-		return method.is_empty() and named in Values.components_of(holder)
+		return method.is_empty() and named in Serialisation.components_of(holder)
 	if holder is Object:
 		var object: Object = holder
 		if not method.is_empty():
@@ -586,7 +587,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	if composite(holder):
 		var kind: String = type_string(typeof(holder))
 		var sort: String = ("an " if kind.left(1) in ["A", "E", "I", "O", "U"] else "a ") + kind
-		var has: String = ", ".join(Values.components_of(holder))
+		var has: String = ", ".join(Serialisation.components_of(holder))
 		if not container_call.is_empty():
 			return (
 				"%s is %s, which a path reads by its components, %s, and makes no call on"

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

@@ -134,6 +134,28 @@ static func acceptable(value: Variant, type: int) -> bool:
 	return Serialisation.acceptable(value, type)
 
 
+## Whether [param given] would have to be cut to become a [param type]: a fraction made a whole
+## number, or a number other than 0 or 1 made a truth.
+##
+## A number arrives from JSON as a float, so one is converted to what the slot holds, and the
+## conversion truncates: 2.5 written into an int was stored as 2 and answered as written, and 0.2 on
+## a bool became true. A number written as text counts as the number.
+static func cuts(given: Variant, type: int) -> bool:
+	if type != TYPE_INT and type != TYPE_BOOL:
+		return false
+	var number: Variant = given
+	if given is String:
+		var text: String = given
+		number = Read.json_or_null(text)
+	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
+		return false
+	var value: float = Read.as_float(number)
+	var whole: bool = value == floorf(value)
+	if type == TYPE_INT:
+		return not whole
+	return not (whole and (value == 0.0 or value == 1.0))
+
+
 ## How a value of [param type] is written to be read as one, or empty when it is not built from fields.
 static func written_as(type: int) -> String:
 	return Serialisation.written_as(type)
@@ -167,52 +189,6 @@ func parameter_class(object: Object, method: String, index: int) -> String:
 	return ""
 
 
-## The components a path reads off [param value], by the names GDScript gives them, or none for a
-## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
-## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
-## into a component is a write into the copy until it is put back where it was read from.
-static func components_of(value: Variant) -> PackedStringArray:
-	match typeof(value):
-		TYPE_VECTOR2, TYPE_VECTOR2I:
-			return PackedStringArray(["x", "y"])
-		TYPE_VECTOR3, TYPE_VECTOR3I:
-			return PackedStringArray(["x", "y", "z"])
-		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
-			return PackedStringArray(["x", "y", "z", "w"])
-		TYPE_COLOR:
-			return PackedStringArray(
-				[
-					"r",
-					"g",
-					"b",
-					"a",
-					"r8",
-					"g8",
-					"b8",
-					"a8",
-					"h",
-					"s",
-					"v",
-					"ok_hsl_h",
-					"ok_hsl_s",
-					"ok_hsl_l"
-				]
-			)
-		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
-			return PackedStringArray(["position", "size", "end"])
-		TYPE_PLANE:
-			return PackedStringArray(["normal", "x", "y", "z", "d"])
-		TYPE_BASIS:
-			return PackedStringArray(["x", "y", "z"])
-		TYPE_TRANSFORM2D:
-			return PackedStringArray(["x", "y", "origin"])
-		TYPE_TRANSFORM3D:
-			return PackedStringArray(["basis", "origin"])
-		TYPE_PROJECTION:
-			return PackedStringArray(["x", "y", "z", "w"])
-	return PackedStringArray()
-
-
 ## What the slot [param named] on [param holder] declares it holds, as `{"type": int, "class":
 ## String, "script": Script or null}`: a property's declaration, or the element type of a typed list
 ## or the value type of a typed map. TYPE_NIL when nothing is declared, which is also what a
@@ -228,7 +204,7 @@ static func components_of(value: Variant) -> PackedStringArray:
 static func slot_declared(holder: Variant, named: String) -> Dictionary:
 	# A component holds one kind of value and no other: a vector's axis is a number, its integer
 	# form's an integer, a rectangle's size a vector of the same form.
-	if named in components_of(holder):
+	if named in Serialisation.components_of(holder):
 		var component: Variant = holder[named]
 		return {"type": typeof(component), "class": "", "script": null}
 	if holder is Array:

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

@@ -312,19 +312,7 @@ static func _in_order(compare: String, limit: float, current: Variant) -> bool:
 ## conversion truncates: 3.5 waited on an int became 3 and 0.2 on a bool became true, and a property
 ## already holding that answered met at once, about a state nobody asked for.
 static func _cut_to_fit(given: Variant, type: int, node_path: String, property: String) -> String:
-	if type != TYPE_INT and type != TYPE_BOOL:
-		return ""
-	var number: Variant = given
-	if given is String:
-		var text: String = given
-		number = Read.json_or_null(text)
-	if typeof(number) != TYPE_FLOAT and typeof(number) != TYPE_INT:
-		return ""
-	var value: float = Read.as_float(number)
-	var whole: bool = value == floorf(value)
-	if type == TYPE_INT and whole:
-		return ""
-	if type == TYPE_BOOL and whole and (value == 0.0 or value == 1.0):
+	if not Values.cuts(given, type):
 		return ""
 	return (
 		(

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

@@ -246,6 +246,52 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## The components a path reads off [param value], by the names GDScript gives them, or none for a
+## value that has none: a vector's axes, a colour's channels, a rectangle's corners and size, a
+## transform's basis and origin. A value of one of these is a copy wherever it is read, so a write
+## into a component is a write into the copy until it is put back where it was read from.
+static func components_of(value: Variant) -> PackedStringArray:
+	match typeof(value):
+		TYPE_VECTOR2, TYPE_VECTOR2I:
+			return PackedStringArray(["x", "y"])
+		TYPE_VECTOR3, TYPE_VECTOR3I:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_VECTOR4, TYPE_VECTOR4I, TYPE_QUATERNION:
+			return PackedStringArray(["x", "y", "z", "w"])
+		TYPE_COLOR:
+			return PackedStringArray(
+				[
+					"r",
+					"g",
+					"b",
+					"a",
+					"r8",
+					"g8",
+					"b8",
+					"a8",
+					"h",
+					"s",
+					"v",
+					"ok_hsl_h",
+					"ok_hsl_s",
+					"ok_hsl_l"
+				]
+			)
+		TYPE_RECT2, TYPE_RECT2I, TYPE_AABB:
+			return PackedStringArray(["position", "size", "end"])
+		TYPE_PLANE:
+			return PackedStringArray(["normal", "x", "y", "z", "d"])
+		TYPE_BASIS:
+			return PackedStringArray(["x", "y", "z"])
+		TYPE_TRANSFORM2D:
+			return PackedStringArray(["x", "y", "origin"])
+		TYPE_TRANSFORM3D:
+			return PackedStringArray(["basis", "origin"])
+		TYPE_PROJECTION:
+			return PackedStringArray(["x", "y", "z", "w"])
+	return PackedStringArray()
+
+
 ## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
 static func pairs(entries: Variant) -> bool:
 	if not entries is Array:

package/build/godot/operations/audio_buses.gd

@@ -83,7 +83,20 @@ func get_audio_buses(_params: Dictionary) -> Dictionary:
 	var buses: Array[Dictionary] = []
 	for i: int in range(AudioServer.bus_count):
 		buses.append(_bus(i))
-	return {"bus_count": AudioServer.bus_count, "buses": buses, "layout": _layout_path()}
+	var layout: String = _layout_path()
+	var answer: Dictionary = {"bus_count": AudioServer.bus_count, "buses": buses, "layout": layout}
+	# The setting names a path whether or not anything is there, and a project that never changed a
+	# bus has no file: the path alone read as a layout the project keeps.
+	if not FileAccess.file_exists(layout):
+		answer["layout_on_disk"] = false
+		answer["note"] = (
+			(
+				"Nothing is at %s, so these are the engine's default buses; the first change to a bus "
+				+ "writes the layout there."
+			)
+			% layout
+		)
+	return answer
 
 
 func set_audio_bus_effect(params: Dictionary) -> Dictionary: