gdharness 1.3.42 → 1.3.43

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

@@ -1,8 +1,7 @@
 @tool
 extends Node
-
-## Animations and animation trees, edited in the open editor or, for a project no editor serves, by a
-## headless engine.
+## Animations and animation trees, edited in the open editor or, for a project no editor serves, by
+## a headless engine.
 
 const GdhAnimationReads = preload("../animation_reads.gd")
 const GdhHeadlessCheck = preload("../headless_check.gd")
@@ -11,9 +10,10 @@ const GdhRead = preload("../reading.gd")
 const GdhSceneFile = preload("../scene_file.gd")
 const GdhSceneUids = preload("../scene_uids.gd")
 const GdhSerialisation = preload("../serialisation.gd")
-
 const LOOP_MODES: Dictionary = {
-	"none": Animation.LOOP_NONE, "linear": Animation.LOOP_LINEAR, "pingpong": Animation.LOOP_PINGPONG
+	"none": Animation.LOOP_NONE,
+	"linear": Animation.LOOP_LINEAR,
+	"pingpong": Animation.LOOP_PINGPONG,
 }
 
 var _editor_plugin: EditorPlugin = null
@@ -74,7 +74,9 @@ func _not_of_kind(scene: GdhSceneFile, node: Node, node_path: String, kind: Stri
 
 ## Writes [param scene] once [param check] passes, then the files of [param homes], answering
 ## [param answer] or a refusal.
-func _finish(scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Dictionary) -> Dictionary:
+func _finish(
+	scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Dictionary
+) -> Dictionary:
 	if not Engine.is_editor_hint():
 		for file: Variant in homes:
 			var home: Resource = homes[file]
@@ -85,9 +87,9 @@ func _finish(scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Di
 						(
 							(
 								(
-									"Nothing was written: %s holds a resource with a script that is not a tool, and what "
-									+ "that script changed when a headless engine loaded it cannot be told apart from the "
-									+ "edit. "
+									"Nothing was written: %s holds a resource with a script that "
+									+ "is not a tool, and what that script changed when a headless "
+									+ "engine loaded it cannot be told apart from the edit. "
 								)
 								% file
 							)
@@ -102,7 +104,7 @@ func _finish(scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Di
 		var resource: Resource = homes[file]
 		var saving: Error = GdhSceneUids.save_keeping_uid(resource, str(file))
 		if saving != OK:
-			return {"ok": false, "error": "Failed to save %s: %s" % [file, error_string(saving)]}
+			return { "ok": false, "error": "Failed to save %s: %s" % [file, error_string(saving)] }
 		if Engine.is_editor_hint():
 			EditorInterface.get_resource_filesystem().update_file(str(file))
 	return answer
@@ -112,7 +114,10 @@ func _finish(scene: GdhSceneFile, check: Callable, homes: Dictionary, answer: Di
 ## engine ran as it loaded the file.
 func _scripted(resource: Resource) -> bool:
 	var script: Script = resource.get_script()
-	return (script != null and not script.is_tool()) or GdhHeadlessCheck.holds_scripted_embedded(resource, {})
+	return (
+		(script != null and not script.is_tool())
+		or GdhHeadlessCheck.holds_scripted_embedded(resource, {})
+	)
 
 
 func _parse_json_maybe(value: Variant) -> Variant:
@@ -160,11 +165,11 @@ func _homes(scene: GdhSceneFile, held: Array) -> Array:
 			false,
 			(
 				(
-					"The %s is kept in %s, not in %s, and an edit here would not be saved there. Edit it "
-					+ "where it is kept instead."
+					"The %s is kept in %s, not in %s, and an edit here would not be saved there. "
+					+ "Edit it where it is kept instead."
 				)
 				% [entry[1], at.get_slice("::", 0), scene.path]
-			)
+			),
 		]
 	return [true, homes]
 
@@ -198,7 +203,9 @@ func _library_of(player: AnimationPlayer, animation_name: String) -> AnimationLi
 ## The state machine at [param state_machine_path] in [param anim_tree], with the files it is kept
 ## in, as [machine, homes, why not].
 func _machine(scene: GdhSceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
-	var sm: AnimationNodeStateMachine = GdhAnimationReads.state_machine(anim_tree, state_machine_path)
+	var sm: AnimationNodeStateMachine = GdhAnimationReads.state_machine(
+		anim_tree, state_machine_path
+	)
 	if not sm:
 		return [null, {}, GdhAnimationReads.no_machine(anim_tree, state_machine_path)]
 	var homes: Array = _homes(scene, [[sm, "state machine"]])
@@ -225,7 +232,7 @@ func read_animations(args: Dictionary) -> Dictionary:
 	var player_node_path: String = str(args.get("playerNodePath", "."))
 	var animation_name: String = str(args.get("animationName", ""))
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 
 	var opened: Array = _read_at(scene_path, player_node_path, "AnimationPlayer")
 	var scene: GdhSceneFile = opened[0]
@@ -250,9 +257,9 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 	var anim_tree_path: String = str(args.get("animTreePath", ""))
 	var state_machine_path: String = str(args.get("stateMachinePath", ""))
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if anim_tree_path.is_empty():
-		return {"ok": false, "error": "Missing animTreePath"}
+		return { "ok": false, "error": "Missing animTreePath" }
 
 	var opened: Array = _read_at(scene_path, anim_tree_path, "AnimationTree")
 	var scene: GdhSceneFile = opened[0]
@@ -264,7 +271,8 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 	var player_path: String = "" if player == null else scene.path_of(player)
 	var unplayed: String = GdhAnimationReads.no_player(str(anim_tree.anim_player), reached)
 	return _read_in(
-		scene, GdhAnimationReads.states(anim_tree, state_machine_path, player, player_path, unplayed)
+		scene,
+		GdhAnimationReads.states(anim_tree, state_machine_path, player, player_path, unplayed)
 	)
 
 
@@ -278,18 +286,18 @@ func create_animation(args: Dictionary) -> Dictionary:
 	var loop_mode_name: String = str(args.get("loopMode", "none"))
 
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	var named: String = _name_refusal(animation_name)
 	if not named.is_empty():
-		return {"ok": false, "error": named}
+		return { "ok": false, "error": named }
 	var loop_modes: Dictionary = LOOP_MODES
 	if not loop_modes.has(loop_mode_name):
-		return {"ok": false, "error": "Unsupported loopMode: " + loop_mode_name}
+		return { "ok": false, "error": "Unsupported loopMode: " + loop_mode_name }
 	var timing: String = _timing_refusal(args)
 	if not timing.is_empty():
-		return {"ok": false, "error": timing}
+		return { "ok": false, "error": timing }
 
 	var opened: Array = _open_at(scene_path, player_node_path, "AnimationPlayer")
 	var scene: GdhSceneFile = opened[0]
@@ -310,7 +318,9 @@ func create_animation(args: Dictionary) -> Dictionary:
 	anim.length = GdhRead.as_float(args.get("length", 1.0), 1.0)
 	anim.loop_mode = GdhRead.as_int(loop_modes[loop_mode_name]) as Animation.LoopMode
 	anim.step = GdhRead.as_float(args.get("step", 0.1), 0.1)
-	var called: String = animation_name.get_slice("/", 1) if animation_name.contains("/") else animation_name
+	var called: String = (
+		animation_name.get_slice("/", 1) if animation_name.contains("/") else animation_name
+	)
 	# As the editor names a new one: the file keeps it as resource_name, which the inspector shows.
 	anim.resource_name = called
 	var add_err: Error = anim_lib.add_animation(StringName(called), anim)
@@ -327,10 +337,12 @@ func create_animation(args: Dictionary) -> Dictionary:
 		"ok": true,
 		"animationName": animation_name,
 		"length": GdhAnimationReads.held_seconds(anim.length),
-		"loopMode": loop_mode_name
+		"loopMode": loop_mode_name,
 	}
 	if library[2]:
-		answer["libraryMade"] = animation_name.get_slice("/", 0) if animation_name.contains("/") else ""
+		answer["libraryMade"] = (
+			animation_name.get_slice("/", 0) if animation_name.contains("/") else ""
+		)
 	var files: Dictionary = homes[1]
 	return _finish(scene, check, files, answer)
 
@@ -341,8 +353,8 @@ static func _name_refusal(animation_name: String) -> String:
 	if animation_name.count("/") > 1:
 		return (
 			(
-				"%s names a library and an animation in it with one slash, as moves/walk; a library holds no "
-				+ "libraries."
+				"%s names a library and an animation in it with one slash, as moves/walk; a "
+				+ "library holds no libraries."
 			)
 			% animation_name
 		)
@@ -372,7 +384,9 @@ static func _past_length(anim: Animation, animation_name: String) -> String:
 
 ## The pastLength sentence for [param past], keys of [param anim] each named by its track's path and
 ## time, or "" for none.
-static func _past_sentence(anim: Animation, animation_name: String, past: PackedStringArray) -> String:
+static func _past_sentence(
+	anim: Animation, animation_name: String, past: PackedStringArray
+) -> String:
 	if past.is_empty():
 		return ""
 	return (
@@ -407,7 +421,10 @@ static func _timing_refusal(args: Dictionary) -> String:
 	if args.has("length"):
 		var length: Variant = args["length"]
 		if not (length is float or length is int) or GdhRead.as_float(length) <= 0.0:
-			return "length is the animation's length in seconds, more than 0, and %s is not." % _given(length)
+			return (
+				"length is the animation's length in seconds, more than 0, and %s is not."
+				% _given(length)
+			)
 	if args.has("step"):
 		var step: Variant = args["step"]
 		if not (step is float or step is int) or GdhRead.as_float(step) < 0.0:
@@ -443,16 +460,19 @@ func set_animation(args: Dictionary) -> Dictionary:
 	var animation_name: String = str(args.get("animationName", ""))
 	var loop_mode_name: String = str(args.get("loopMode", ""))
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	if not (args.has("length") or args.has("loopMode") or args.has("step")):
-		return {"ok": false, "error": "set changes length, loopMode or step, and was given none of them."}
+		return {
+			"ok": false,
+			"error": "set changes length, loopMode or step, and was given none of them.",
+		}
 	if args.has("loopMode") and not LOOP_MODES.has(loop_mode_name):
-		return {"ok": false, "error": "Unsupported loopMode: " + loop_mode_name}
+		return { "ok": false, "error": "Unsupported loopMode: " + loop_mode_name }
 	var timing: String = _timing_refusal(args)
 	if not timing.is_empty():
-		return {"ok": false, "error": timing}
+		return { "ok": false, "error": timing }
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
 	if found[1] == null:
@@ -479,7 +499,10 @@ func set_animation(args: Dictionary) -> Dictionary:
 		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 not is_equal_approx(copy.get_animation(StringName(animation_name)).length, length):
-			return "%s would not be %s s long when the scene loads." % [animation_name, _seconds(length)]
+			return (
+				"%s would not be %s s long when the scene loads."
+				% [animation_name, _seconds(length)]
+			)
 		return ""
 	var answer: Dictionary = {
 		"ok": true,
@@ -504,12 +527,14 @@ func rename_animation(args: Dictionary) -> Dictionary:
 	var animation_name: String = str(args.get("animationName", ""))
 	var new_name: String = str(args.get("newName", "")).strip_edges()
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 	if new_name.is_empty():
-		return {"ok": false, "error": "Missing newName"}
-	var library_name: String = animation_name.get_slice("/", 0) if animation_name.contains("/") else ""
+		return { "ok": false, "error": "Missing newName" }
+	var library_name: String = (
+		animation_name.get_slice("/", 0) if animation_name.contains("/") else ""
+	)
 	var prefix: String = "" if library_name.is_empty() else library_name + "/"
 	if not prefix.is_empty() and new_name.begins_with(prefix):
 		new_name = new_name.trim_prefix(prefix)
@@ -519,15 +544,18 @@ func rename_animation(args: Dictionary) -> Dictionary:
 			"error":
 			(
 				(
-					"rename keeps an animation in its library (%s), so newName is its name there, with "
-					+ "no library before a slash."
+					"rename keeps an animation in its library (%s), so newName is its name there, "
+					+ "with no library before a slash."
 				)
 				% ("the default one" if library_name.is_empty() else library_name)
 			),
 		}
 	for forbidden: String in [":", ",", "["]:
 		if new_name.contains(forbidden):
-			return {"ok": false, "error": "An animation's name cannot hold : , or [, and %s does." % new_name}
+			return {
+				"ok": false,
+				"error": "An animation's name cannot hold : , or [, and %s does." % new_name,
+			}
 	var new_full: String = prefix + new_name
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
@@ -557,7 +585,7 @@ func rename_animation(args: Dictionary) -> Dictionary:
 	# As the editor's rename sets it: the library's key alone left the file's resource_name, which
 	# the inspector shows, on the old name.
 	player.get_animation(StringName(new_full)).resource_name = new_name
-	var answer: Dictionary = {"ok": true, "animationName": new_full, "was": animation_name}
+	var answer: Dictionary = { "ok": true, "animationName": new_full, "was": animation_name }
 	if autoplayed:
 		answer["autoplay"] = new_full
 	var followed: Array = []
@@ -585,9 +613,9 @@ func remove_animation(args: Dictionary) -> Dictionary:
 	var player_node_path: String = str(args.get("playerNodePath", "."))
 	var animation_name: String = str(args.get("animationName", ""))
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		return { "ok": false, "error": "Missing animationName" }
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
 	if found[1] == null:
@@ -598,12 +626,14 @@ func remove_animation(args: Dictionary) -> Dictionary:
 	var homes: Array = _homes(scene, [[library, "animation library"]])
 	if not homes[0]:
 		return scene.refuse(str(homes[1]))
-	var called: String = animation_name.get_slice("/", 1) if animation_name.contains("/") else animation_name
+	var called: String = (
+		animation_name.get_slice("/", 1) if animation_name.contains("/") else animation_name
+	)
 	var autoplayed: bool = str(player.autoplay) == animation_name
 	library.remove_animation(StringName(called))
 	if player.has_animation(StringName(animation_name)):
 		return scene.refuse("The library did not let go of %s." % animation_name)
-	var answer: Dictionary = {"ok": true, "removed": animation_name}
+	var answer: Dictionary = { "ok": true, "removed": animation_name }
 	if autoplayed:
 		player.autoplay = ""
 		answer["autoplayCleared"] = true

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

@@ -1,8 +1,7 @@
 @tool
 extends "animation_tools.gd"
-
-## The tracks and keys of an animation, beside the players and libraries the script it extends edits,
-## whose helpers it shares.
+## The tracks and keys of an animation, beside the players and libraries the script it extends
+## edits, whose helpers it shares.
 
 
 # =============================================================================
@@ -15,19 +14,19 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 	var given_track: Variant = args.get("track", {})
 
 	if scene_path.strip_edges() == "res://":
-		return {"ok": false, "error": "Missing scenePath"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		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"}
-	# The schema leaves keyframes out of what track requires, since remove_track finds a track without
-	# them.
+		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"}
+		return { "ok": false, "error": "Missing track.keyframes" }
 	var keyed: Array = _keyframes(track)
 	if not keyed[0]:
-		return {"ok": false, "error": keyed[1]}
+		return { "ok": false, "error": keyed[1] }
 
 	# Asked of the player, which knows every library: looking only in the default one refused
 	# "moves/walk" as missing.
@@ -48,13 +47,16 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		target_path = "."
 	var target: Node = _animated(player, target_path)
 	if target == null:
-		return scene.refuse(
-			(
+		return (
+			scene
+			. refuse(
 				(
-					"No node at %s from the player's root node, %s, which is what the track path is read "
-					+ "against."
+					(
+						"No node at %s from the player's root node, %s, which is what the track "
+						+ "path is read against."
+					)
+					% [target_path, str(player.root_node)]
 				)
-				% [target_path, str(player.root_node)]
 			)
 		)
 	var keyframes: Array = keyed[1]
@@ -120,7 +122,12 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 ## animates: two tracks for one path both play, the later overriding the earlier, and a key meant
 ## to extend the motion was split off where reading the animation showed two halves.
 func _add_track(
-	anim: Animation, track: Dictionary, target: Node, target_path: String, keyframes: Array, replacing: bool
+	anim: Animation,
+	track: Dictionary,
+	target: Node,
+	target_path: String,
+	keyframes: Array,
+	replacing: bool
 ) -> Array:
 	var track_type: String = str(track.get("type", ""))
 	var keys: Array = []
@@ -148,7 +155,7 @@ func _add_track(
 				return _not_added("keyframes[%d].args must be a list." % index)
 			var raw: Array = given
 			var arguments: Array = _fitted(target, method_name, _parse_method_args(raw))
-			keys.append({"method": method_name, "args": arguments})
+			keys.append({ "method": method_name, "args": arguments })
 			if misfit.is_empty():
 				misfit = _key_misfit(target, method_name, arguments, index)
 		method_found = target.has_method(method_name)
@@ -156,7 +163,10 @@ func _add_track(
 	else:
 		return _not_added(
 			(
-				"add_track makes property and method tracks, and track.type is %s; remove_track takes any."
+				(
+					"add_track makes property and method tracks, and track.type is %s; "
+					+ "remove_track takes any."
+				)
 				% track_type
 			)
 		)
@@ -178,14 +188,16 @@ func _add_track(
 				return _not_added(
 					(
 						(
-							"Track %d already animates %s and has a key at %s s, which keyframes[%d] would "
-							+ "replace. Nothing was written; replaceKeys true replaces it."
+							"Track %d already animates %s and has a key at %s s, which "
+							+ "keyframes[%d] would replace. Nothing was written; replaceKeys true "
+							+ "replaces it."
 						)
 						% [track_idx, str(path), _seconds(time), index]
 					)
 				)
-			# A method key's value is its call, {"method": ..., "args": [...]}. The time is as asked:
-			# the key's own, read back from a scene's 32-bit times, puts 0.1 at 0.100000001490116.
+			# A method key's value is its call, {"method": ..., "args": [...]}. The time is as
+			# asked: the key's own, read back from a scene's 32-bit times, puts 0.1 at
+			# 0.100000001490116.
 			(
 				replaced
 				. append(
@@ -228,7 +240,9 @@ static func _fitted(target: Node, method: String, arguments: Array) -> Array:
 			declared = GdhRead.as_int(parameter.get("type", TYPE_NIL))
 		if value is float and declared != TYPE_FLOAT:
 			var number: float = value
-			if is_finite(number) and number == floorf(number) and absf(number) < 9007199254740992.0:
+			if (is_finite(number)
+					and number == floorf(number)
+					and absf(number) < 9_007_199_254_740_992.0):
 				value = int(number)
 		fitted.append(value)
 	return fitted
@@ -256,10 +270,16 @@ static func _key_misfit(target: Node, method: String, arguments: Array, index: i
 		else ("1 argument" if arguments.size() == 1 else "%d arguments" % arguments.size())
 	)
 	if arguments.size() < needed:
-		return "keyframes[%d] calls %s with %s, and it needs %d%s" % [index, method, passed, needed, fails]
+		return (
+			"keyframes[%d] calls %s with %s, and it needs %d%s"
+			% [index, method, passed, needed, fails]
+		)
 	if arguments.size() > parameters.size():
 		var most: String = "none" if parameters.is_empty() else "at most %d" % parameters.size()
-		return "keyframes[%d] calls %s with %s, and it takes %s%s" % [index, method, passed, most, fails]
+		return (
+			"keyframes[%d] calls %s with %s, and it takes %s%s"
+			% [index, method, passed, most, fails]
+		)
 	for at: int in arguments.size():
 		var parameter: Dictionary = parameters[at]
 		var taken_type: int = GdhRead.as_int(parameter.get("type", TYPE_NIL))
@@ -276,7 +296,7 @@ static func _key_misfit(target: Node, method: String, arguments: Array, index: i
 					method,
 					str(parameter.get("name", "")),
 					type_string(taken_type),
-					fails
+					fails,
 				]
 			)
 	return ""
@@ -293,22 +313,22 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 	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"}
+		return { "ok": false, "error": "Missing scenePath" }
 	if animation_name.strip_edges().is_empty():
-		return {"ok": false, "error": "Missing animationName"}
+		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"}
+		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}
+		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 method: String = str(track.get("method", "")) if track_type == "method" else ""
 	var read_times: Variant = _times_of(args.get("times"))
 	if read_times is String:
-		return {"ok": false, "error": read_times}
+		return { "ok": false, "error": read_times }
 	var times: Array = read_times
 
 	var found: Array = _animation_at(scene_path, player_node_path, animation_name)
@@ -335,7 +355,7 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 			% [
 				animation_name,
 				track_type,
-				node_path if property.is_empty() else "%s:%s" % [node_path, property]
+				node_path if property.is_empty() else "%s:%s" % [node_path, property],
 			]
 		)
 		if held.is_empty():
@@ -353,7 +373,9 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 		var timed: Array = _keys_at(anim, calling, times)
 		if timed[1] != "":
 			var on: String = node_path if property.is_empty() else "%s:%s" % [node_path, property]
-			return scene.refuse("%s's %s track on %s %s" % [animation_name, track_type, on, timed[1]])
+			return scene.refuse(
+				"%s's %s track on %s %s" % [animation_name, track_type, on, timed[1]]
+			)
 		calling = timed[0]
 	var keys: int = 0
 	var tracks_removed: int = 0
@@ -383,7 +405,7 @@ func remove_animation_track(args: Dictionary) -> Dictionary:
 		if loaded.get_track_count() != left or _key_total(loaded) != keys_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}
+	var removed: Dictionary = { "type": track_type, "nodePath": node_path }
 	if not property.is_empty():
 		removed["property"] = property
 	if not method.is_empty():
@@ -432,8 +454,8 @@ static func _times_of(given: Variant) -> Variant:
 
 
 ## Of the keys [param calling] names, as [method _keys_calling] answers them, the ones at
-## [param times], as [[[track, key]...], ""], or with the second the words refusing a time none is at.
-## Removing a key took removing its whole track, so moving one key in time rewrote every other.
+## [param times], as [[[track, key]...], ""], or with the second the words refusing a time none is
+## at. Removing a key took removing its whole track, so moving one key in time rewrote every other.
 static func _keys_at(anim: Animation, calling: Array, times: Array) -> Array:
 	var at: Array = []
 	var held: PackedStringArray = []
@@ -457,7 +479,10 @@ static func _keys_at(anim: Animation, calling: Array, times: Array) -> Array:
 		var _named: bool = named.append(str(given))
 	return [
 		at,
-		"has no key at %s s; its keys are at %s s. Nothing was removed." % [", ".join(named), ", ".join(held)]
+		(
+			"has no key at %s s; its keys are at %s s. Nothing was removed."
+			% [", ".join(named), ", ".join(held)]
+		),
 	]
 
 
@@ -483,7 +508,9 @@ static func _key_total(anim: Animation) -> int:
 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))),
+		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()),
 	]
@@ -508,7 +535,8 @@ func _keyframes(track: Dictionary) -> Array:
 		var seconds: float = GdhRead.as_float(time)
 		if times.has(seconds):
 			return [
-				false, "keyframes[%d] and [%d] are both at %s seconds." % [times[seconds], index, seconds]
+				false,
+				"keyframes[%d] and [%d] are both at %s seconds." % [times[seconds], index, seconds],
 			]
 		times[seconds] = index
 	return [true, keyframes]
@@ -530,7 +558,9 @@ func _key_values(target: Node, prop_name: String, keyframes: Array) -> Array:
 			# A subname such as position:x keys one component, which is a number.
 			var component: Variant = _properties.parse(raw, TYPE_FLOAT)
 			if not component is float:
-				return [false, "keyframes[%d].value keys %s, which is a number." % [index, prop_name]]
+				return [
+					false, "keyframes[%d].value keys %s, which is a number." % [index, prop_name],
+				]
 			values.append(component)
 			continue
 		var value: Array = _properties.value_for(target, declared, raw)