gdharness 1.2.32 → 1.2.34

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

@@ -3,36 +3,18 @@ extends Node
 
 ## Animations and animation trees, edited in the open editor.
 
+const AnimationReads = preload("../animation_reads.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
-const LOOP_MODE_NAMES: Dictionary[int, String] = {
-	Animation.LOOP_NONE: "none",
-	Animation.LOOP_LINEAR: "linear",
-	Animation.LOOP_PINGPONG: "pingpong",
-}
-const TRACK_TYPE_NAMES: Dictionary[int, String] = {
-	Animation.TYPE_VALUE: "property",
-	Animation.TYPE_POSITION_3D: "position_3d",
-	Animation.TYPE_ROTATION_3D: "rotation_3d",
-	Animation.TYPE_SCALE_3D: "scale_3d",
-	Animation.TYPE_BLEND_SHAPE: "blend_shape",
-	Animation.TYPE_METHOD: "method",
-	Animation.TYPE_BEZIER: "bezier",
-	Animation.TYPE_AUDIO: "audio",
-	Animation.TYPE_ANIMATION: "animation",
-}
-const SWITCH_MODE_NAMES: Dictionary[int, String] = {
-	AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE: "immediate",
-	AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC: "sync",
-	AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END: "at_end",
-}
+## 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
 
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
-var _values: Serialisation = Serialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -177,33 +159,12 @@ func _library_of(player: AnimationPlayer, animation_name: String) -> AnimationLi
 	return player.get_animation_library(StringName(library))
 
 
-## The state machine at a slash-separated path of nested state machine names, or null when
-## any step of the path is not one. Every node in a tree of state machines is a state machine
-## itself, so the walk asks each step for the child by name and refuses anything else.
-func _get_state_machine(
-	anim_tree: AnimationTree, state_machine_path: String = ""
-) -> AnimationNodeStateMachine:
-	if not anim_tree:
-		return null
-	if state_machine_path.is_empty() or state_machine_path == "root":
-		return anim_tree.tree_root as AnimationNodeStateMachine
-
-	var current: AnimationNodeStateMachine = anim_tree.tree_root as AnimationNodeStateMachine
-	for segment: String in state_machine_path.split("/", false):
-		if segment.is_empty():
-			continue
-		if current == null or not current.has_node(StringName(segment)):
-			return null
-		current = current.get_node(StringName(segment)) as AnimationNodeStateMachine
-	return current
-
-
 ## 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: SceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
-	var sm: AnimationNodeStateMachine = _get_state_machine(anim_tree, state_machine_path)
+	var sm: AnimationNodeStateMachine = AnimationReads.state_machine(anim_tree, state_machine_path)
 	if not sm:
-		return [null, {}, "AnimationNodeStateMachine not found"]
+		return [null, {}, AnimationReads.no_machine(anim_tree, state_machine_path)]
 	var homes: Array = _homes(scene, [[sm, "state machine"]])
 	if not homes[0]:
 		return [null, {}, homes[1]]
@@ -235,77 +196,18 @@ func read_animations(args: Dictionary) -> Dictionary:
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
-	var answer: Dictionary = {"ok": true, "unsavedInEditor": SceneFile.unsaved(scene_path)}
-	if animation_name.is_empty():
-		var listed: Array[Dictionary] = []
-		for called: String in player.get_animation_list():
-			var listed_one: Animation = player.get_animation(StringName(called))
-			var summary: Dictionary = _summary(listed_one)
-			summary["animationName"] = called
-			summary["tracks"] = listed_one.get_track_count()
-			listed.append(summary)
-		answer["animations"] = listed
-		scene.close()
-		return answer
-	if not player.has_animation(StringName(animation_name)):
-		var names: PackedStringArray = player.get_animation_list()
-		return scene.refuse(
-			(
-				"%s has no animation %s. It has: %s."
-				% [player.name, animation_name, ", ".join(names) if not names.is_empty() else "none"]
-			)
-		)
+	return _read_in(scene, AnimationReads.animations(player, animation_name))
 
-	var anim: Animation = player.get_animation(StringName(animation_name))
-	answer.merge(_summary(anim))
-	answer["animationName"] = animation_name
-	var tracks: Array[Dictionary] = []
-	for track: int in anim.get_track_count():
-		tracks.append(_track(anim, track))
-	answer["tracks"] = tracks
+
+## [param answer] read from [param scene], with whether the editor holds the scene unsaved.
+func _read_in(scene: SceneFile, answer: Dictionary) -> Dictionary:
+	if not answer.get("ok", false):
+		return scene.refuse(str(answer.get("error", "")))
+	answer["unsavedInEditor"] = SceneFile.unsaved(scene.path)
 	scene.close()
 	return answer
 
 
-func _summary(anim: Animation) -> Dictionary:
-	return {
-		"length": anim.length,
-		"loopMode": LOOP_MODE_NAMES.get(anim.loop_mode, str(anim.loop_mode)),
-		"step": anim.step,
-	}
-
-
-func _track(anim: Animation, track: int) -> Dictionary:
-	var kind: int = anim.track_get_type(track)
-	var path: NodePath = anim.track_get_path(track)
-	var shaped: Dictionary = {
-		"type": TRACK_TYPE_NAMES.get(kind, str(kind)), "nodePath": str(path.get_concatenated_names())
-	}
-	var property: String = str(path.get_concatenated_subnames())
-	if not property.is_empty():
-		shaped["property"] = property
-	var keyframes: Array[Dictionary] = []
-	var methods: Dictionary = {}
-	for key: int in anim.track_get_key_count(track):
-		var keyframe: Dictionary = {"time": anim.track_get_key_time(track, key)}
-		if kind == Animation.TYPE_METHOD:
-			var method: String = str(anim.method_track_get_name(track, key))
-			methods[method] = true
-			keyframe["method"] = method
-			keyframe["args"] = _values.serialize_value(anim.method_track_get_params(track, key))
-		else:
-			keyframe["value"] = _values.serialize_value(anim.track_get_key_value(track, key))
-		keyframes.append(keyframe)
-	# One method across every key is the track's, as add_track takes it. Keys calling different
-	# methods, which the editor can make and add_track cannot, keep their own.
-	if methods.size() == 1:
-		shaped["method"] = methods.keys()[0]
-		for keyframe: Dictionary in keyframes:
-			var _shared: bool = keyframe.erase("method")
-	shaped["keyframes"] = keyframes
-	return shaped
-
-
 ## The states and transitions of a state machine in an AnimationTree.
 func read_animation_states(args: Dictionary) -> Dictionary:
 	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
@@ -321,36 +223,7 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
-	var sm: AnimationNodeStateMachine = _get_state_machine(anim_tree, state_machine_path)
-	if sm == null:
-		return scene.refuse("AnimationNodeStateMachine not found")
-
-	var states: Array[Dictionary] = []
-	for state: StringName in sm.get_node_list():
-		var node: AnimationNode = sm.get_node(state)
-		var entry: Dictionary = {"stateName": str(state), "type": node.get_class()}
-		if node is AnimationNodeAnimation:
-			var plays: AnimationNodeAnimation = node
-			entry["animationName"] = str(plays.animation)
-		states.append(entry)
-	var transitions: Array[Dictionary] = []
-	for index: int in sm.get_transition_count():
-		var transition: AnimationNodeStateMachineTransition = sm.get_transition(index)
-		var shaped: Dictionary = {
-			"from": str(sm.get_transition_from(index)),
-			"to": str(sm.get_transition_to(index)),
-			"transitionType": SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
-		}
-		if not str(transition.advance_condition).is_empty():
-			shaped["advanceCondition"] = str(transition.advance_condition)
-		transitions.append(shaped)
-	scene.close()
-	return {
-		"ok": true,
-		"states": states,
-		"transitions": transitions,
-		"unsavedInEditor": SceneFile.unsaved(scene_path),
-	}
+	return _read_in(scene, AnimationReads.states(anim_tree, state_machine_path))
 
 
 # =============================================================================
@@ -611,13 +484,26 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 		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
 	if player != null and not player.has_animation(StringName(animation_name)):
+		# By its path from the scene root, as playerNodePath takes it; anim_player is relative to the
+		# tree ("../Anim"), which no argument takes.
 		return scene.refuse(
-			"%s has no animation %s for the state to play." % [str(anim_tree.anim_player), animation_name]
+			(
+				"The AnimationPlayer at %s has no animation %s for the state to play."
+				% [str(scene.root.get_path_to(player)), animation_name]
+			)
 		)
 
 	var anim_node: AnimationNodeAnimation = AnimationNodeAnimation.new()
 	anim_node.animation = StringName(animation_name)
-	sm.add_node(StringName(state_name), anim_node)
+	# 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)
 
@@ -627,6 +513,7 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 		"animationName": animation_name,
 		# False when the tree has no player to look the animation up in.
 		"animationFound": player != null,
+		"position": Serialisation.new().serialize_value(position),
 	}
 	var files: Dictionary = machine[1]
 	return _finish(scene, Callable(), files, answer)

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

@@ -243,6 +243,10 @@ func read_resource(args: Dictionary) -> Dictionary:
 	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
 	if res_path == "res://":
 		return {"ok": false, "error": "resourcePath is required"}
+	# The server takes a resource kept inside a file apart, so the boundary judges the file alone.
+	var inner: String = str(args.get("subResource", ""))
+	if not inner.is_empty():
+		res_path += "::" + inner
 	return FileReads.resource(res_path, Read.as_bool(args.get("includeDefaults", false)))
 
 

package/build/godot/operations/animation_reads.gd

@@ -0,0 +1,224 @@
+extends RefCounted
+
+## Animations and state machines read off their nodes: by the editor's tools from the scene it holds,
+## and by a headless engine with none connected from a bare node of the class given what the file
+## stores, which runs no script of the scene's, so a read answers the same either way.
+
+const FileReads = preload("file_reads.gd")
+const Serialisation = preload("serialisation.gd")
+
+const LOOP_MODE_NAMES: Dictionary[int, String] = {
+	Animation.LOOP_NONE: "none",
+	Animation.LOOP_LINEAR: "linear",
+	Animation.LOOP_PINGPONG: "pingpong",
+}
+const TRACK_TYPE_NAMES: Dictionary[int, String] = {
+	Animation.TYPE_VALUE: "property",
+	Animation.TYPE_POSITION_3D: "position_3d",
+	Animation.TYPE_ROTATION_3D: "rotation_3d",
+	Animation.TYPE_SCALE_3D: "scale_3d",
+	Animation.TYPE_BLEND_SHAPE: "blend_shape",
+	Animation.TYPE_METHOD: "method",
+	Animation.TYPE_BEZIER: "bezier",
+	Animation.TYPE_AUDIO: "audio",
+	Animation.TYPE_ANIMATION: "animation",
+}
+const SWITCH_MODE_NAMES: Dictionary[int, String] = {
+	AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE: "immediate",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_SYNC: "sync",
+	AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END: "at_end",
+}
+
+
+## [method animations] of the AnimationPlayer at [param player_path] in the file [param scene_path].
+static func scene_animations(scene_path: String, player_path: String, animation_name: String) -> Dictionary:
+	var made: Array = _bare(scene_path, player_path, "AnimationPlayer")
+	if made[0] == null:
+		return made[1]
+	var player: AnimationPlayer = made[0]
+	var answer: Dictionary = animations(player, animation_name)
+	player.free()
+	return answer
+
+
+## [method states] of the AnimationTree at [param tree_path] in the file [param scene_path].
+static func scene_states(scene_path: String, tree_path: String, state_machine_path: String) -> Dictionary:
+	var made: Array = _bare(scene_path, tree_path, "AnimationTree")
+	if made[0] == null:
+		return made[1]
+	var tree: AnimationTree = made[0]
+	var answer: Dictionary = states(tree, state_machine_path)
+	tree.free()
+	return answer
+
+
+## A node of the class the file gives the node at [param node_path], holding every property the
+## files set but its script, as [node, null] or [null, refusal]. The caller frees it.
+static func _bare(scene_path: String, node_path: String, kind: String) -> Array:
+	var read: Dictionary = FileReads.scene_node(scene_path, node_path)
+	if not read.is_empty() and not read.get("ok", false):
+		return [null, read]
+	var type: String = str(read.get("type", ""))
+	if not ClassDB.class_exists(type) or not ClassDB.is_parent_class(type, kind):
+		return [null, {"ok": false, "error": "%s not found at: %s" % [kind, node_path]}]
+	var bare: Node = ClassDB.instantiate(type)
+	bare.name = str(read["name"])
+	var given: Dictionary = read["properties"]
+	for property: Variant in given:
+		if str(property) != "script":
+			bare.set(str(property), given[property])
+	return [bare, null]
+
+
+## The animations of [param player] with their lengths, or [param animation_name] whole when it is
+## given. A track comes back in the shape add_track takes, so one read here can be written to
+## another animation as it stands.
+static func animations(player: AnimationPlayer, animation_name: String) -> Dictionary:
+	if animation_name.is_empty():
+		var listed: Array[Dictionary] = []
+		for called: String in player.get_animation_list():
+			var listed_one: Animation = player.get_animation(StringName(called))
+			var summary: Dictionary = _summary(listed_one)
+			summary["animationName"] = called
+			summary["tracks"] = listed_one.get_track_count()
+			listed.append(summary)
+		return {"ok": true, "animations": listed}
+	if not player.has_animation(StringName(animation_name)):
+		var names: PackedStringArray = player.get_animation_list()
+		return {
+			"ok": false,
+			"error":
+			(
+				"%s has no animation %s. It has: %s."
+				% [player.name, animation_name, ", ".join(names) if not names.is_empty() else "none"]
+			)
+		}
+	var anim: Animation = player.get_animation(StringName(animation_name))
+	var answer: Dictionary = _summary(anim)
+	answer["ok"] = true
+	answer["animationName"] = animation_name
+	var tracks: Array[Dictionary] = []
+	var values: Serialisation = Serialisation.new()
+	for track: int in anim.get_track_count():
+		tracks.append(_track(anim, track, values))
+	answer["tracks"] = tracks
+	return answer
+
+
+static func _summary(anim: Animation) -> Dictionary:
+	return {
+		"length": anim.length,
+		"loopMode": LOOP_MODE_NAMES.get(anim.loop_mode, str(anim.loop_mode)),
+		"step": anim.step,
+	}
+
+
+static func _track(anim: Animation, track: int, values: Serialisation) -> Dictionary:
+	var kind: int = anim.track_get_type(track)
+	var path: NodePath = anim.track_get_path(track)
+	var shaped: Dictionary = {
+		"type": TRACK_TYPE_NAMES.get(kind, str(kind)), "nodePath": str(path.get_concatenated_names())
+	}
+	var property: String = str(path.get_concatenated_subnames())
+	if not property.is_empty():
+		shaped["property"] = property
+	var keyframes: Array[Dictionary] = []
+	var methods: Dictionary = {}
+	for key: int in anim.track_get_key_count(track):
+		var keyframe: Dictionary = {"time": anim.track_get_key_time(track, key)}
+		if kind == Animation.TYPE_METHOD:
+			var method: String = str(anim.method_track_get_name(track, key))
+			methods[method] = true
+			keyframe["method"] = method
+			keyframe["args"] = values.serialize_value(anim.method_track_get_params(track, key))
+		else:
+			keyframe["value"] = values.serialize_value(anim.track_get_key_value(track, key))
+		keyframes.append(keyframe)
+	# One method across every key is the track's, as add_track takes it. Keys calling different
+	# methods, which the editor can make and add_track cannot, keep their own.
+	if methods.size() == 1:
+		shaped["method"] = methods.keys()[0]
+		for keyframe: Dictionary in keyframes:
+			var _shared: bool = keyframe.erase("method")
+	shaped["keyframes"] = keyframes
+	return shaped
+
+
+## The state machine at a slash-separated path of nested state machine names in [param tree], or
+## null when any step of the path is not one. Every node in a tree of state machines is a state
+## machine itself, so the walk asks each step for the child by name and refuses anything else.
+static func state_machine(tree: AnimationTree, state_machine_path: String) -> AnimationNodeStateMachine:
+	if tree == null:
+		return null
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if state_machine_path == "root":
+		return current
+	for segment: String in state_machine_path.split("/", false):
+		if current == null or not current.has_node(StringName(segment)):
+			return null
+		current = current.get_node(StringName(segment)) as AnimationNodeStateMachine
+	return current
+
+
+## Why [method state_machine] found none at [param state_machine_path] in [param tree]: the step of
+## the path that failed, and what is there instead.
+static func no_machine(tree: AnimationTree, state_machine_path: String) -> String:
+	if tree == null or tree.tree_root == null:
+		return "The AnimationTree has no tree_root."
+	var current: AnimationNodeStateMachine = tree.tree_root as AnimationNodeStateMachine
+	if current == null:
+		return (
+			"The AnimationTree's tree_root is not a state machine: its type is %s."
+			% tree.tree_root.get_class()
+		)
+	var walked: PackedStringArray = []
+	for segment: String in state_machine_path.split("/", false):
+		var where: String = "the root state machine"
+		if not walked.is_empty():
+			where = "the state machine at " + "/".join(walked)
+		if not current.has_node(StringName(segment)):
+			var names: PackedStringArray = []
+			for state: StringName in current.get_node_list():
+				if state != &"Start" and state != &"End":
+					var _listed: bool = names.push_back(str(state))
+			var held: String = ", ".join(names) if not names.is_empty() else "none"
+			return (
+				"%s has no state %s. Its states are: %s."
+				% [where.to_upper()[0] + where.substr(1), segment, held]
+			)
+		var next: AnimationNode = current.get_node(StringName(segment))
+		if not next is AnimationNodeStateMachine:
+			return (
+				"The state %s in %s is not a state machine: its type is %s."
+				% [segment, where, next.get_class()]
+			)
+		current = next
+		var _walked: bool = walked.push_back(segment)
+	return "No state machine at " + state_machine_path
+
+
+## The states and transitions of the state machine at [param state_machine_path] in [param tree].
+static func states(tree: AnimationTree, state_machine_path: String) -> Dictionary:
+	var sm: AnimationNodeStateMachine = state_machine(tree, state_machine_path)
+	if sm == null:
+		return {"ok": false, "error": no_machine(tree, state_machine_path)}
+	var listed: Array[Dictionary] = []
+	for state: StringName in sm.get_node_list():
+		var node: AnimationNode = sm.get_node(state)
+		var entry: Dictionary = {"stateName": str(state), "type": node.get_class()}
+		if node is AnimationNodeAnimation:
+			var plays: AnimationNodeAnimation = node
+			entry["animationName"] = str(plays.animation)
+		listed.append(entry)
+	var transitions: Array[Dictionary] = []
+	for index: int in sm.get_transition_count():
+		var transition: AnimationNodeStateMachineTransition = sm.get_transition(index)
+		var shaped: Dictionary = {
+			"from": str(sm.get_transition_from(index)),
+			"to": str(sm.get_transition_to(index)),
+			"transitionType": SWITCH_MODE_NAMES.get(transition.switch_mode, str(transition.switch_mode)),
+		}
+		if not str(transition.advance_condition).is_empty():
+			shaped["advanceCondition"] = str(transition.advance_condition)
+		transitions.append(shaped)
+	return {"ok": true, "states": listed, "transitions": transitions}

package/build/godot/operations/file_reads.gd

@@ -19,6 +19,30 @@ const Serialisation = preload("serialisation.gd")
 ## instances another scene and every stored property when [param include_properties] is set, the
 ## file's value or the default where it sets none. [param depth] -1 reads every level.
 static func scene_tree(scene_path: String, depth: int, include_properties: bool) -> Dictionary:
+	var laid: Dictionary = _laid(scene_path)
+	if not laid.get("ok", false):
+		return laid
+	var nodes: Dictionary = laid["nodes"]
+	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+
+
+## The node at [param node_path] in [param scene_path] as {ok, name, type, properties}, laid as
+## [method scene_tree] lays it, with only the properties the files set; {} when the scene has no
+## node there, and a refusal when the file does not read as a scene.
+static func scene_node(scene_path: String, node_path: String) -> Dictionary:
+	var laid: Dictionary = _laid(scene_path)
+	if not laid.get("ok", false):
+		return laid
+	var nodes: Dictionary = laid["nodes"]
+	var path: String = _joined(".", node_path)
+	if not nodes.has(path):
+		return {}
+	var found: Dictionary = nodes[path]
+	return {"ok": true, "name": found["name"], "type": found["type"], "properties": found["properties"]}
+
+
+## Every node of [param scene_path] as {ok, nodes}, keyed by path, or a refusal.
+static func _laid(scene_path: String) -> Dictionary:
 	if not FileAccess.file_exists(scene_path):
 		return {"ok": false, "error": "Scene not found: " + scene_path}
 	# Loaded without naming the type, so a resource handed in by mistake loads as what it is and the
@@ -42,7 +66,7 @@ static func scene_tree(scene_path: String, depth: int, include_properties: bool)
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
-	return {"ok": true, "tree": _entry(nodes, ".", include_properties, depth, 0)}
+	return {"ok": true, "nodes": nodes}
 
 
 ## Lays the nodes of [param state] into [param nodes] under [param prefix], keyed by their path
@@ -192,12 +216,22 @@ static func _stored(type: String, given: Dictionary) -> Dictionary:
 ## What a resource file holds, in the form modify takes, so a value read here can be written back.
 ## Read from the file rather than a cached copy, since the file is what the writes change and what
 ## the project loads.
+##
+## [param res_path] may name a resource kept inside a file, as "res://hero.tscn::Animation_jump",
+## the path a property holding one is read back with.
 static func resource(res_path: String, include_defaults: bool) -> Dictionary:
-	if not FileAccess.file_exists(res_path):
-		return {"ok": false, "error": "No resource at " + res_path}
-	var loaded: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	var file: String = res_path.get_slice("::", 0)
+	if not FileAccess.file_exists(file):
+		return {"ok": false, "error": "No resource at " + file}
+	var loaded: Resource = ResourceLoader.load(file, "", ResourceLoader.CACHE_MODE_IGNORE)
 	if loaded == null:
-		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+		return {"ok": false, "error": "%s did not load as a resource." % file}
+	if file != res_path:
+		var id: String = res_path.trim_prefix(file + "::")
+		var inner: Resource = _kept_in(loaded, file, id, {})
+		if inner == null:
+			return {"ok": false, "error": "%s keeps no resource with the id %s." % [file, id]}
+		loaded = inner
 	# A scene's own properties are its packed bundle, which says nothing a caller can use.
 	if loaded is PackedScene:
 		return {
@@ -235,3 +269,40 @@ static func resource(res_path: String, include_defaults: bool) -> Dictionary:
 	if script != null:
 		answer["script"] = script.resource_path
 	return answer
+
+
+## The resource [param file] keeps under [param id], found in [param value] or anything it holds.
+## The engine loads such a path only while the file is cached, and a read loads the file uncached,
+## so it is looked for among what the file holds. A resource of another file is neither taken nor
+## walked into: ids are unique only within one file, and a scene instancing another holds that
+## file's resources under ids of the other file's.
+static func _kept_in(value: Variant, file: String, id: String, seen: Dictionary) -> Resource:
+	if value is Resource:
+		var held: Resource = value
+		if seen.has(held.get_instance_id()):
+			return null
+		seen[held.get_instance_id()] = true
+		var at: String = held.resource_path
+		if not at.is_empty() and at.get_slice("::", 0) != file:
+			return null
+		if held.resource_scene_unique_id == id:
+			return held
+		for p: Dictionary in held.get_property_list():
+			if Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE:
+				var found: Resource = _kept_in(held.get(str(p.get("name", ""))), file, id, seen)
+				if found != null:
+					return found
+	elif value is Array:
+		var items: Array = value
+		for item: Variant in items:
+			var found: Resource = _kept_in(item, file, id, seen)
+			if found != null:
+				return found
+	elif value is Dictionary:
+		var entries: Dictionary = value
+		for key: Variant in entries:
+			for side: Variant in [key, entries[key]]:
+				var found: Resource = _kept_in(side, file, id, seen)
+				if found != null:
+					return found
+	return null

package/build/godot/operations/godot_operations.gd

@@ -14,6 +14,7 @@ extends SceneTree
 # the operations directory ships inside the server package and is handed to the engine as an
 # absolute path outside the project. A res:// path would only resolve in the test fixture.
 
+const AnimationReads = preload("animation_reads.gd")
 const AudioBuses = preload("audio_buses.gd")
 const ClassCache = preload("class_cache.gd")
 const ClassDbQueries = preload("classdb_queries.gd")
@@ -153,6 +154,22 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 					str(params.get("resource_path", "")), Read.as_bool(params.get("include_defaults", false))
 				)
 			)
+		"read_animations":
+			payload = _read(
+				AnimationReads.scene_animations(
+					str(params.get("scene_path", "")),
+					str(params.get("player_node_path", ".")),
+					str(params.get("animation_name", ""))
+				)
+			)
+		"read_animation_states":
+			payload = _read(
+				AnimationReads.scene_states(
+					str(params.get("scene_path", "")),
+					str(params.get("anim_tree_path", "")),
+					str(params.get("state_machine_path", ""))
+				)
+			)
 
 		# Import and export pipeline
 		"get_import_status":