gdharness 1.3.0 → 1.3.2

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

@@ -4,19 +4,19 @@ extends Node
 ## Animations and animation trees, edited in the open editor or, for a project no editor serves, by a
 ## headless engine.
 
-const AnimationReads = preload("../animation_reads.gd")
-const HeadlessCheck = preload("../headless_check.gd")
-const PropertyValues = preload("../property_values.gd")
-const Read = preload("../reading.gd")
-const SceneFile = preload("../scene_file.gd")
-const Serialisation = preload("../serialisation.gd")
+const GdhAnimationReads = preload("../animation_reads.gd")
+const GdhHeadlessCheck = preload("../headless_check.gd")
+const GdhPropertyValues = preload("../property_values.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+const GdhSerialisation = preload("../serialisation.gd")
 
 ## 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 _properties: GdhPropertyValues = GdhPropertyValues.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -42,15 +42,13 @@ func _find_node(root: Node, path: String) -> Node:
 ## [param kind] the scene owns. Answers [scene, node, refusal]; the refusal is {} when both were
 ## found.
 func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
-	var scene: SceneFile = SceneFile.new()
+	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, true)
 	if not refused.is_empty():
 		return [scene, null, refused]
 	var node: Node = _find_node(scene.root, node_path)
 	if node == null or not node.is_class(kind):
-		return [
-			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
-		]
+		return [scene, null, _not_of_kind(scene, node, node_path, kind)]
 	var foreign: String = scene.foreign(node)
 	if not foreign.is_empty():
 		return [scene, null, scene.refuse(foreign)]
@@ -60,21 +58,34 @@ func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
 ## [param scene_path] opened for reading, as [method _open_at] answers. A node an instanced scene
 ## owns is read like any other, since nothing is written.
 func _read_at(scene_path: String, node_path: String, kind: String) -> Array:
-	var scene: SceneFile = SceneFile.new()
+	var scene: GdhSceneFile = GdhSceneFile.new()
 	var refused: Dictionary = scene.open(scene_path, false)
 	if not refused.is_empty():
 		return [scene, null, refused]
 	var node: Node = _find_node(scene.root, node_path)
 	if node == null or not node.is_class(kind):
-		return [
-			scene, null, scene.refuse(scene.not_found("%s not found at: %s" % [kind, node_path], node_path))
-		]
+		return [scene, null, _not_of_kind(scene, node, node_path, kind)]
 	return [scene, node, {}]
 
 
+## The refusal for [param node_path] in [param scene], where [param node] is what the scene has
+## there, null or not a [param kind], with where the scene's nodes of that kind are.
+func _not_of_kind(scene: GdhSceneFile, node: Node, node_path: String, kind: String) -> Dictionary:
+	var said: String = "%s not found at: %s" % [kind, node_path]
+	if node == null:
+		said = scene.not_found(said, node_path)
+	var held: PackedStringArray = []
+	if scene.root.is_class(kind):
+		var _root_held: bool = held.append(".")
+	for found: Node in scene.root.find_children("*", kind, true, false):
+		var _held: bool = held.append(str(scene.root.get_path_to(found)))
+	var there: String = "" if node == null else node.get_class()
+	return scene.refuse(GdhRead.not_of_kind(said, node_path, there, kind, held))
+
+
 ## Writes [param scene] once [param check] passes, then the files of [param homes], answering
 ## [param answer] or a refusal.
-func _finish(scene: SceneFile, 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]
@@ -91,7 +102,7 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 								)
 								% file
 							)
-							+ HeadlessCheck.REMEDY
+							+ GdhHeadlessCheck.REMEDY
 						)
 					)
 				)
@@ -100,7 +111,7 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 		return written
 	for file: Variant in homes:
 		var resource: Resource = homes[file]
-		var saving: Error = SceneFile.save_keeping_uid(resource, str(file))
+		var saving: Error = GdhSceneFile.save_keeping_uid(resource, str(file))
 		if saving != OK:
 			return {"ok": false, "error": "Failed to save %s: %s" % [file, error_string(saving)]}
 		if Engine.is_editor_hint():
@@ -112,14 +123,14 @@ func _finish(scene: SceneFile, check: Callable, homes: Dictionary, answer: Dicti
 ## 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 HeadlessCheck.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:
 	if typeof(value) != TYPE_STRING:
 		return value
 	var text: String = value
-	var parsed: Variant = Read.json_or_null(text)
+	var parsed: Variant = GdhRead.json_or_null(text)
 	if parsed == null and text != "null":
 		return value
 	return parsed
@@ -140,7 +151,7 @@ func _parse_method_args(raw_args: Array) -> Array:
 ## edited in memory while only the scene was saved, which refers to the file, so the edit was
 ## answered as made and was gone; it is saved too. One inside some other file (an imported model,
 ## the scene this one inherits from) is refused, since nothing written here would keep the edit.
-func _homes(scene: SceneFile, held: Array) -> Array:
+func _homes(scene: GdhSceneFile, held: Array) -> Array:
 	var homes: Dictionary = {}
 	for entry: Array in held:
 		var resource: Resource = entry[0]
@@ -195,10 +206,10 @@ 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: SceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
-	var sm: AnimationNodeStateMachine = AnimationReads.state_machine(anim_tree, state_machine_path)
+func _machine(scene: GdhSceneFile, anim_tree: AnimationTree, state_machine_path: String) -> Array:
+	var sm: AnimationNodeStateMachine = GdhAnimationReads.state_machine(anim_tree, state_machine_path)
 	if not sm:
-		return [null, {}, AnimationReads.no_machine(anim_tree, state_machine_path)]
+		return [null, {}, GdhAnimationReads.no_machine(anim_tree, state_machine_path)]
 	var homes: Array = _homes(scene, [[sm, "state machine"]])
 	if not homes[0]:
 		return [null, {}, homes[1]]
@@ -226,18 +237,18 @@ func read_animations(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing scenePath"}
 
 	var opened: Array = _read_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
-	return _read_in(scene, AnimationReads.animations(player, animation_name))
+	return _read_in(scene, GdhAnimationReads.animations(player, animation_name))
 
 
 ## [param answer] read from [param scene], with whether the editor holds the scene unsaved.
-func _read_in(scene: SceneFile, answer: Dictionary) -> Dictionary:
+func _read_in(scene: GdhSceneFile, answer: Dictionary) -> Dictionary:
 	if not answer.get("ok", false):
 		return scene.refuse(str(answer.get("error", "")))
-	answer["unsavedInEditor"] = SceneFile.unsaved(scene.path)
+	answer["unsavedInEditor"] = GdhSceneFile.unsaved(scene.path)
 	scene.close()
 	return answer
 
@@ -253,11 +264,11 @@ func read_animation_states(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Missing animTreePath"}
 
 	var opened: Array = _read_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
-	return _read_in(scene, AnimationReads.states(anim_tree, state_machine_path))
+	return _read_in(scene, GdhAnimationReads.states(anim_tree, state_machine_path))
 
 
 # =============================================================================
@@ -280,7 +291,7 @@ func create_animation(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Unsupported loopMode: " + loop_mode_name}
 
 	var opened: Array = _open_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
@@ -295,9 +306,9 @@ func create_animation(args: Dictionary) -> Dictionary:
 		return scene.refuse(str(homes[1]))
 
 	var anim: Animation = Animation.new()
-	anim.length = Read.as_float(args.get("length", 1.0), 1.0)
-	anim.loop_mode = Read.as_int(loop_modes[loop_mode_name]) as Animation.LoopMode
-	anim.step = Read.as_float(args.get("step", 0.1), 0.1)
+	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 add_err: Error = anim_lib.add_animation(StringName(called), anim)
 	if add_err != OK:
@@ -337,7 +348,7 @@ func add_animation_track(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": keyed[1]}
 
 	var opened: Array = _open_at(scene_path, player_node_path, "AnimationPlayer")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var player: AnimationPlayer = opened[1]
@@ -429,7 +440,7 @@ func _add_track(
 
 	for index: int in keyframes.size():
 		var keyframe: Dictionary = keyframes[index]
-		if anim.track_insert_key(track_idx, Read.as_float(keyframe["time"]), keys[index]) < 0:
+		if anim.track_insert_key(track_idx, GdhRead.as_float(keyframe["time"]), keys[index]) < 0:
 			return [-1, "Keyframe %d could not be inserted." % index, null]
 	return [track_idx, "", method_found]
 
@@ -450,7 +461,7 @@ func _keyframes(track: Dictionary) -> Array:
 		var time: Variant = keyframe.get("time")
 		if not (time is float or time is int):
 			return [false, "keyframes[%d] has no time." % index]
-		var seconds: float = Read.as_float(time)
+		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]
@@ -504,7 +515,7 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 			return {"ok": false, "error": "Missing " + str(required[1])}
 
 	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]
@@ -547,7 +558,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),
+		"position": GdhSerialisation.new().serialize_value(position),
 	}
 	var files: Dictionary = machine[1]
 	return _finish(scene, Callable(), files, answer)
@@ -580,13 +591,13 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Unsupported transitionType: " + transition_type}
 	var transition: AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition.new()
 	transition.switch_mode = (
-		Read.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
+		GdhRead.as_int(modes[transition_type]) as AnimationNodeStateMachineTransition.SwitchMode
 	)
 	if not advance_condition.is_empty():
 		transition.advance_condition = StringName(advance_condition)
 
 	var opened: Array = _open_at(scene_path, anim_tree_path, "AnimationTree")
-	var scene: SceneFile = opened[0]
+	var scene: GdhSceneFile = opened[0]
 	if opened[1] == null:
 		return opened[2]
 	var anim_tree: AnimationTree = opened[1]

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

@@ -4,8 +4,8 @@ extends Node
 ## The editor's view of the files on disk: scans, the reimports asked for, where each stands, and
 ## files moved under it.
 
-const Read = preload("../reading.gd")
-const SceneFile = preload("../scene_file.gd")
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -63,7 +63,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 	var started: bool = false
 	var completed_before: int = _scans_completed
 	var uids: Dictionary = {"reread": [], "duplicated": []}
-	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
+	if not GdhRead.as_bool(args.get("statusOnly", false)) and not busy:
 		uids = _reread_changed_uids(filesystem)
 		# Files the caller has just written, moved or deleted, read again one by one. The scan finds a
 		# script that appeared and leaves the global class of one that has gone in the editor's list,
@@ -172,7 +172,7 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
-		"pending": SceneFile.scan_due,
+		"pending": GdhSceneFile.scan_due,
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
 		"reimportsCompleted": _reimports_completed,

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

@@ -9,7 +9,7 @@ extends Node
 ## tools answer at all.
 
 ## What the display server calls itself when the engine was started with no display at all.
-const Read = preload("../reading.gd")
+const GdhRead = preload("../reading.gd")
 
 const HEADLESS_DISPLAY: String = "headless"
 ## Where Godot keeps the port its own debugger listens on for a game it is playing. One setting
@@ -245,7 +245,7 @@ func playing_status(_args: Dictionary) -> Dictionary:
 	# play, so the one from when this editor greeted the server is a number it has moved off.
 	var settings: EditorSettings = EditorInterface.get_editor_settings()
 	var debugger: int = (
-		Read.as_int(settings.get_setting(DEBUGGER_SETTING))
+		GdhRead.as_int(settings.get_setting(DEBUGGER_SETTING))
 		if settings != null and settings.has_setting(DEBUGGER_SETTING)
 		else 0
 	)

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

@@ -10,7 +10,7 @@ extends Node
 ## `debug_data` signal every ScriptEditorDebugger emits for every message, on a node Godot does not
 ## expose to scripts: found by its class in the editor's tree and connected to by name.
 
-const Read = preload("../reading.gd")
+const GdhRead = preload("../reading.gd")
 
 ## The most functions a frame may carry when the server does not say. The engine names a function
 ## once, as it first appears, and the game's debugger queue drops those messages past its size, so
@@ -28,7 +28,7 @@ const PROFILE_FROM_START: String = "GDHARNESS_PROFILE_FROM_START"
 
 
 ## The editor's debugger sessions, numbered as the editor numbers its debugger tabs.
-class Sessions:
+class GdhSessions:
 	extends EditorDebuggerPlugin
 
 	signal session_started(session_id: int)
@@ -53,7 +53,7 @@ class Sessions:
 
 
 var _editor_plugin: EditorPlugin = null
-var _sessions: Sessions = null
+var _sessions: GdhSessions = null
 ## The debugger tabs connected to, by instance id, so none is connected twice.
 var _hooked: Dictionary[int, bool] = {}
 
@@ -75,7 +75,7 @@ var _totals: Dictionary[String, PackedFloat64Array] = {}
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
-	_sessions = Sessions.new()
+	_sessions = GdhSessions.new()
 	var joined: int = _sessions.session_started.connect(_on_session_started)
 	if joined != OK:
 		push_error("gdharness could not watch debugger sessions start: %d" % joined)
@@ -105,9 +105,9 @@ func profile_start(args: Dictionary) -> Dictionary:
 			),
 		}
 	_reset()
-	var asked: int = Read.as_int(args.get("frameFunctions", FRAME_FUNCTIONS))
+	var asked: int = GdhRead.as_int(args.get("frameFunctions", FRAME_FUNCTIONS))
 	_frame_functions = asked if asked > 0 else FRAME_FUNCTIONS
-	if Read.as_bool(args.get("arm", false)):
+	if GdhRead.as_bool(args.get("arm", false)):
 		_armed = true
 		# The game the editor starts next inherits the editor's environment, and this tells its
 		# runtime addon to hold its start until the profiler is on, which the session's start
@@ -206,7 +206,7 @@ func _on_debug_data(message: String, data: Array, session_id: int) -> void:
 	if session_id != _session:
 		return
 	if message == "servers:function_signature" and data.size() >= 2:
-		_names[Read.as_int(data[1])] = str(data[0])
+		_names[GdhRead.as_int(data[1])] = str(data[0])
 	elif message == "servers:profile_frame":
 		var carried: int = _add(data, _totals)
 		if carried >= 0:
@@ -231,28 +231,28 @@ func _add(data: Array, into: Dictionary[String, PackedFloat64Array]) -> int:
 	var at: int = 6
 	if data.size() <= at:
 		return -1
-	var servers: int = Read.as_int(data[at])
+	var servers: int = GdhRead.as_int(data[at])
 	at += 1
 	for _server: int in servers:
 		if data.size() <= at + 1:
 			return -1
-		at += 2 + Read.as_int(data[at + 1])
+		at += 2 + GdhRead.as_int(data[at + 1])
 	if data.size() <= at:
 		return -1
-	var values: int = Read.as_int(data[at])
+	var values: int = GdhRead.as_int(data[at])
 	at += 1
 	if values % 5 != 0 or data.size() < at + values:
 		return -1
 	var carried: int = 0
 	for index: int in range(at, at + values, 5):
-		var id: int = Read.as_int(data[index])
+		var id: int = GdhRead.as_int(data[index])
 		var signature: String = _names[id] if _names.has(id) else "#%d" % id
 		var sum: PackedFloat64Array = (
 			into[signature] if into.has(signature) else PackedFloat64Array([0, 0, 0])
 		)
-		sum[0] += Read.as_float(data[index + 1])
-		sum[1] += Read.as_float(data[index + 2])
-		sum[2] += Read.as_float(data[index + 3])
+		sum[0] += GdhRead.as_float(data[index + 1])
+		sum[1] += GdhRead.as_float(data[index + 2])
+		sum[2] += GdhRead.as_float(data[index + 3])
 		into[signature] = sum
 		carried += 1
 	return carried