gdharness 1.3.8 → 1.3.9

package/build/godot/addons/gdharness_editor/file_reads.gd

@@ -119,6 +119,9 @@ static func _laid(scene_path: String) -> Dictionary:
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	var base: SceneState = packed.get_state().get_base_scene_state()
+	if base != null:
+		nodes["."]["inherits"] = base.get_path()
 	return {"ok": true, "nodes": nodes}
 
 
@@ -175,6 +178,10 @@ static func _lay(
 				nodes[path] = _made(str(state.get_node_type(index)))
 			if ids[index] >= 0:
 				nodes[path]["uniqueId"] = ids[index]
+			# Laid at the root with no scene handed in is a scene the one being read inherits, and the
+			# deepest is laid first, so this is the file that makes the node.
+			if prefix == "." and loaded == null:
+				nodes[path]["inheritedFrom"] = state.get_path()
 		# The name is the state's even for an entry laid already, since an inherited scene names its
 		# root itself; a root instanced inside another scene is renamed by that scene once laid.
 		if not recovered:
@@ -324,6 +331,12 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	# An inherited scene's file holds only what it changes, so the read says what it inherits and
+	# which nodes come from there, as the editor greys them.
+	if node.has("inherits"):
+		data["inherits"] = node["inherits"]
+	elif node.has("inheritedFrom"):
+		data["inheritedFrom"] = node["inheritedFrom"]
 	var groups: Array[String] = node["groups"]
 	if not groups.is_empty():
 		var sorted: Array[String] = groups.duplicate()

package/build/godot/addons/gdharness_editor/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

package/build/godot/addons/gdharness_editor/scene_file.gd

@@ -50,6 +50,8 @@ static var by_path: PackedStringArray = []
 
 var root: Node = null
 var path: String = ""
+## What the last write saved, for its answer to read what the file now stores.
+var written_pack: PackedScene = null
 ## The path of each node a scene this one inherits gives, with the file that makes it.
 var _base_paths: Dictionary = {}
 var _state: SceneState = null
@@ -91,18 +93,7 @@ func open(scene_path: String, for_writing: bool) -> Dictionary:
 	if root == null:
 		return {"ok": false, "error": "Failed to instantiate " + path}
 	_state = packed.get_state()
-	var base: SceneState = _state.get_base_scene_state()
-	# Each node a base gives, with the file that makes it: the deepest base listing it as more than
-	# values set on a node from further down.
-	while base != null:
-		for index: int in base.get_node_count():
-			var given: String = _relative(str(base.get_node_path(index)))
-			var made: bool = (
-				base.get_node_instance(index) != null or not str(base.get_node_type(index)).is_empty()
-			)
-			if made or not _base_paths.has(given):
-				_base_paths[given] = base.get_path()
-		base = base.get_base_scene_state()
+	_base_paths = makers(_state)
 	# On a read as well, which would otherwise answer what the scripts set as what the file holds.
 	if not Engine.is_editor_hint():
 		if for_writing:
@@ -179,8 +170,7 @@ func refuse(error: String) -> Dictionary:
 	return {"ok": false, "error": error}
 
 
-## Each bit set in [param flags], a connection's, by name, and whatever bits are left unnamed as one
-## number.
+## Each bit set in [param flags], a connection's, by name, and any bits left unnamed as one number.
 static func flag_names(flags: int) -> Array[String]:
 	var names: Array[String] = []
 	var rest: int = flags
@@ -350,13 +340,20 @@ func _closed_around(node: Node) -> PackedStringArray:
 func fixed(node: Node, deleting: bool = false) -> String:
 	if node == root:
 		return "The root of %s cannot be moved, renamed, copied or deleted." % path
+	if node.owner == null:
+		return foreign(node)
 	if node.owner != root:
-		var why: String = foreign(node)
-		if why.is_empty():
-			why = "%s is inside an instanced scene, which creates it again on load." % path_of(node)
-			if deleting:
-				why += _deleted_elsewhere(node, node.owner.scene_file_path)
-		return why
+		# Editable children keep values here and no more; the scene instanced may have the node from
+		# a scene it inherits, which is the one to edit.
+		var instanced: String = node.owner.scene_file_path
+		var packed: PackedScene = load(instanced) as PackedScene
+		var made_by: Dictionary = makers(packed.get_state()) if packed != null else {}
+		var maker: String = str(made_by.get(str(node.owner.get_path_to(node)), instanced))
+		var inside: String = (
+			"%s is inside the scene instanced at %s (%s), which creates it again on load."
+			% [path_of(node), path_of(node.owner), instanced]
+		)
+		return inside + (_deleted_elsewhere(node, maker) if deleting else " Edit %s instead." % maker)
 	var at: String = path_of(node)
 	if _base_paths.has(at):
 		var maker: String = str(_base_paths[at])
@@ -367,6 +364,23 @@ func fixed(node: Node, deleting: bool = false) -> String:
 	return ""
 
 
+## Each node the scenes [param state] inherits give it, by path, with the deepest file making it more
+## than values; a node [param state] makes itself is not in it.
+static func makers(state: SceneState) -> Dictionary:
+	var made_by: Dictionary = {}
+	var at: SceneState = state.get_base_scene_state()
+	while at != null:
+		for index: int in at.get_node_count():
+			var given: String = _relative(str(at.get_node_path(index)))
+			var made: bool = (
+				at.get_node_instance(index) != null or not str(at.get_node_type(index)).is_empty()
+			)
+			if made or not made_by.has(given):
+				made_by[given] = at.get_path()
+		at = at.get_base_scene_state()
+	return made_by
+
+
 ## What a caller can do with [param node], made by [param maker], instead of deleting it here.
 static func _deleted_elsewhere(node: Node, maker: String) -> String:
 	var hidden: String = (
@@ -583,19 +597,12 @@ func write(check: Callable = Callable()) -> Dictionary:
 			return refuse("Nothing was written: " + str(settled[1]))
 		packed = settled[0]
 		if not path.ends_with(".tscn") and _holds_scripted_embedded():
-			return refuse(
-				(
-					(
-						(
-							"Nothing was written: %s is a binary scene holding an embedded 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 file here. "
-						)
-						% path
-					)
-					+ GdhHeadlessCheck.REMEDY
-				)
+			var binary: String = (
+				"Nothing was written: %s is a binary scene holding an embedded 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 file here. "
 			)
+			return refuse(binary % path + GdhHeadlessCheck.REMEDY)
 	if check.is_valid():
 		var saved: Node = packed.instantiate(PackedScene.GEN_EDIT_STATE_MAIN)
 		if saved == null:
@@ -608,6 +615,7 @@ func write(check: Callable = Callable()) -> Dictionary:
 	var previous: Variant = null
 	if FileAccess.file_exists(path):
 		previous = FileAccess.get_file_as_bytes(path)
+	written_pack = packed
 	var written: Dictionary = save_packed(packed, path)
 	if not written.is_empty() or not headless or not path.ends_with(".tscn"):
 		return written
@@ -988,7 +996,5 @@ static func _stored_at(state: SceneState, index: int) -> Dictionary:
 	return stored
 
 
-func _relative(node_path: String) -> String:
-	if node_path == ".":
-		return node_path
+static func _relative(node_path: String) -> String:
 	return node_path.trim_prefix("./")

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

@@ -142,28 +142,29 @@ func serialize_value(value: Variant) -> Variant:
 		return value
 	var carried: Variant = call(serialiser, value)
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
-	# tagged here; containers reach their members through this function already.
-	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
+	var type: int = typeof(value)
+	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
 # NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
 # back out as null, so a property holding INF was answered as holding nothing.
-func _finite(carried: Variant) -> Variant:
+func _finite(carried: Variant, single: bool = false) -> Variant:
 	if carried is float:
 		var number: float = carried
-		return _serialize_float(number)
+		return _serialize_float(GdhRead.single(number) if single else number)
 	if carried is Dictionary:
 		var fields: Dictionary = carried
 		var tagged: Dictionary = {}
 		for key: Variant in fields:
-			tagged[key] = _finite(fields[key])
+			tagged[key] = _finite(fields[key], single)
 		return tagged
 	if carried is Array:
 		var items: Array = carried
 		var tagged_items: Array = []
 		for item: Variant in items:
-			tagged_items.append(_finite(item))
+			tagged_items.append(_finite(item, single))
 		return tagged_items
 	return carried
 
@@ -189,7 +190,7 @@ func _serialize_floats(value: Variant) -> Variant:
 			for each: float in numbers:
 				items.append(_serialize_float(each))
 			return items
-	return value
+	return numbers if value is PackedFloat32Array else value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -8,6 +8,7 @@ extends Node
 const GdhSceneTools = preload("tools/scene_tools.gd")
 const GdhSignalTools = preload("tools/signal_tools.gd")
 const GdhResourceTools = preload("tools/resource_tools.gd")
+const GdhAnimationStates = preload("tools/animation_states.gd")
 const GdhAnimationTools = preload("tools/animation_tools.gd")
 const GdhPlayTools = preload("tools/play_tools.gd")
 const GdhClassTools = preload("tools/class_tools.gd")
@@ -20,6 +21,7 @@ var _editor_plugin: EditorPlugin = null
 var _scene_tools: GdhSceneTools = null
 var _signal_tools: GdhSignalTools = null
 var _resource_tools: GdhResourceTools = null
+var _animation_states: GdhAnimationStates = null
 var _animation_tools: GdhAnimationTools = null
 var _play_tools: GdhPlayTools = null
 var _class_tools: GdhClassTools = null
@@ -37,6 +39,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_scene_tools.set_editor_plugin(plugin)
 	_resource_tools.set_editor_plugin(plugin)
 	_animation_tools.set_editor_plugin(plugin)
+	_animation_states.set_editor_plugin(plugin)
 	_play_tools.set_editor_plugin(plugin)
 	_class_tools.set_editor_plugin(plugin)
 	_filesystem_tools.set_editor_plugin(plugin)
@@ -64,6 +67,10 @@ func _init_tools() -> void:
 	_animation_tools.name = "AnimationTools"
 	add_child(_animation_tools)
 
+	_animation_states = GdhAnimationStates.new()
+	_animation_states.name = "AnimationStates"
+	add_child(_animation_states)
+
 	_play_tools = GdhPlayTools.new()
 	_play_tools.name = "PlayTools"
 	add_child(_play_tools)
@@ -131,11 +138,14 @@ func _init_tools() -> void:
 		"read_animation_states": [_animation_tools, "read_animation_states"],
 		"create_animation": [_animation_tools, "create_animation"],
 		"add_animation_track": [_animation_tools, "add_animation_track"],
+		"remove_animation_track": [_animation_tools, "remove_animation_track"],
 		"set_animation": [_animation_tools, "set_animation"],
 		"rename_animation": [_animation_tools, "rename_animation"],
 		"remove_animation": [_animation_tools, "remove_animation"],
-		"add_animation_state": [_animation_tools, "add_animation_state"],
-		"connect_animation_states": [_animation_tools, "connect_animation_states"],
+		"add_animation_state": [_animation_states, "add_animation_state"],
+		"connect_animation_states": [_animation_states, "connect_animation_states"],
+		"remove_animation_state": [_animation_states, "remove_animation_state"],
+		"disconnect_animation_states": [_animation_states, "disconnect_animation_states"],
 	}
 
 

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

@@ -0,0 +1,244 @@
+@tool
+extends "animation_tools.gd"
+
+## The states and transitions of an AnimationTree's state machines, beside the players and tracks
+## the script it extends edits, whose helpers it shares.
+
+## 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
+
+
+# =============================================================================
+# add_animation_state
+# =============================================================================
+func add_animation_state(args: Dictionary) -> Dictionary:
+	var state_name: String = str(args.get("stateName", ""))
+	var animation_name: String = str(args.get("animationName", ""))
+	if state_name.is_empty():
+		return {"ok": false, "error": "Missing stateName"}
+	if animation_name.is_empty():
+		return {"ok": false, "error": "Missing animationName"}
+	var machine: Array = _machine_at(args)
+	if machine[1] == null:
+		return machine[3]
+	var scene: GdhSceneFile = machine[0]
+	var sm: AnimationNodeStateMachine = machine[1]
+	var anim_tree: AnimationTree = machine[4]
+	# 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[2]
+	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 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 advance_condition: String = str(args.get("advanceCondition", ""))
+
+	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 found: Array = _machine_at(args)
+	if found[1] == null:
+		return found[3]
+	var scene: GdhSceneFile = found[0]
+	var sm: AnimationNodeStateMachine = found[1]
+	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 = found[2]
+	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 _no_state(sm, 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 ""
+
+
+## The refusal for [param state_name], which [param sm] has no state of: with the nearest names it
+## has, or else every state, since a machine has a handful.
+static func _no_state(sm: AnimationNodeStateMachine, state_name: String) -> String:
+	var said: String = "The state machine has no state named %s" % state_name
+	var states: PackedStringArray = []
+	for state: StringName in sm.get_node_list():
+		var _listed: bool = states.append(str(state))
+	var close: PackedStringArray = GdhRead.nearest(state_name, states)
+	if not close.is_empty():
+		return (
+			"%s; the nearest it has %s %s." % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+		)
+	return "%s; its states are %s." % [said, ", ".join(states)]
+
+
+## The state machine [param args] names, as [scene, machine, files, refusal, tree]: the machine is
+## null and the refusal says why when the scene, the tree or the machine is not there.
+func _machine_at(args: Dictionary) -> Array:
+	var scene_path: String = GdhSceneFile.res_path("", str(args.get("scenePath", "")))
+	var anim_tree_path: String = str(args.get("animTreePath", ""))
+	if scene_path.strip_edges() == "res://":
+		return [null, null, {}, {"ok": false, "error": "Missing scenePath"}]
+	if anim_tree_path.is_empty():
+		return [null, null, {}, {"ok": false, "error": "Missing animTreePath"}]
+	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
+	var scene: GdhSceneFile = opened[0]
+	if opened[1] == null:
+		return [scene, null, {}, opened[2]]
+	var anim_tree: AnimationTree = opened[1]
+	var machine: Array = _machine(scene, anim_tree, str(args.get("stateMachinePath", "")))
+	if machine[0] == null:
+		return [scene, null, {}, scene.refuse(str(machine[2]))]
+	return [scene, machine[0], machine[1], {}, anim_tree]
+
+
+# =============================================================================
+# remove_animation_state, disconnect_animation_states
+# =============================================================================
+## Takes a state out of its state machine with every transition leaving or reaching it, which the
+## engine drops with the state, and names those under transitionsRemoved. Start and End are part of
+## every state machine.
+func remove_animation_state(args: Dictionary) -> Dictionary:
+	var state_name: String = str(args.get("stateName", ""))
+	if state_name.is_empty():
+		return {"ok": false, "error": "Missing stateName"}
+	var found: Array = _machine_at(args)
+	if found[1] == null:
+		return found[3]
+	var scene: GdhSceneFile = found[0]
+	var sm: AnimationNodeStateMachine = found[1]
+	if state_name in ["Start", "End"]:
+		return scene.refuse("%s is part of every state machine, so it cannot be removed." % state_name)
+	if not sm.has_node(StringName(state_name)):
+		return scene.refuse(_no_state(sm, state_name))
+	var dropped: Array = []
+	for index: int in sm.get_transition_count():
+		var from: String = str(sm.get_transition_from(index))
+		var to: String = str(sm.get_transition_to(index))
+		if state_name in [from, to]:
+			dropped.append({"from": from, "to": to})
+	sm.remove_node(StringName(state_name))
+	if sm.has_node(StringName(state_name)):
+		return scene.refuse("The state machine did not let go of %s." % state_name)
+	for index: int in sm.get_transition_count():
+		if state_name in [str(sm.get_transition_from(index)), str(sm.get_transition_to(index))]:
+			return scene.refuse(
+				"The state machine kept a transition of %s after the state went." % state_name
+			)
+	var files: Dictionary = found[2]
+	return _finish(
+		scene, Callable(), files, {"ok": true, "removed": state_name, "transitionsRemoved": dropped}
+	)
+
+
+## Takes out the transition from one state to another.
+func disconnect_animation_states(args: Dictionary) -> Dictionary:
+	var from_state: String = str(args.get("fromState", ""))
+	var to_state: String = str(args.get("toState", ""))
+	if from_state.is_empty() or to_state.is_empty():
+		return {"ok": false, "error": "Missing fromState or toState"}
+	var found: Array = _machine_at(args)
+	if found[1] == null:
+		return found[3]
+	var scene: GdhSceneFile = found[0]
+	var sm: AnimationNodeStateMachine = found[1]
+	for state: String in [from_state, to_state]:
+		if not sm.has_node(StringName(state)):
+			return scene.refuse(_no_state(sm, state))
+	if not sm.has_transition(StringName(from_state), StringName(to_state)):
+		var leaving: PackedStringArray = []
+		for index: int in sm.get_transition_count():
+			if str(sm.get_transition_from(index)) == from_state:
+				var _listed: bool = leaving.append(str(sm.get_transition_to(index)))
+		var said: String = "There is no transition from %s to %s" % [from_state, to_state]
+		if leaving.is_empty():
+			return scene.refuse("%s; none leaves %s." % [said, from_state])
+		return scene.refuse("%s; the ones leaving %s go to %s." % [said, from_state, ", ".join(leaving)])
+	sm.remove_transition(StringName(from_state), StringName(to_state))
+	if sm.has_transition(StringName(from_state), StringName(to_state)):
+		return scene.refuse("The state machine did not let go of the transition.")
+	var files: Dictionary = found[2]
+	return _finish(scene, Callable(), files, {"ok": true, "removed": {"from": from_state, "to": to_state}})

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

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