gdharness 1.3.8 → 1.3.10

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

@@ -0,0 +1,121 @@
+extends RefCounted
+
+## Project settings read the same way headless and from the open editor, because the two are one
+## question asked of two places: a field one of them left out read as the editor and the file
+## disagreeing about something they agree about.
+
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+
+
+## One setting: whether the engine knows it, its value, whether that is the engine's default, and
+## the feature overrides that replace it in some builds.
+static func one(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	var result: Dictionary = {
+		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path)
+	}
+
+	if result["exists"]:
+		var value: Variant = ProjectSettings.get_setting(setting_path)
+		result["value"] = values.serialize_value(value)
+		# A setting the engine registers exists whether or not the project sets it, so exists did
+		# not say whether project.godot has a line for it. At its default it has none: the engine
+		# drops such a key when it saves.
+		var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
+		if default_value != null:
+			result["at_default"] = value == default_value
+	else:
+		result["value"] = null
+		result["message"] = "Setting does not exist"
+
+	# An override exists only while project.godot sets it, so one the file does not set read as a
+	# setting nobody had heard of, when a build with that feature reads its base setting instead.
+	var base: String = override_base(setting_path)
+	if not base.is_empty():
+		result["override_of"] = base
+		if not result["exists"] and ProjectSettings.has_setting(base):
+			result["holds"] = values.serialize_value(ProjectSettings.get_setting(base))
+			result["message"] = overridden_by_none(setting_path, values)
+
+	# The value under this name is not the one every build reads: `name.windows` replaces it on
+	# Windows, `name.editor` in the editor. Read alone, a caller saw the plain value and not the one
+	# their game showed.
+	var overrides: Dictionary = overrides_of(setting_path, values)
+	if not overrides.is_empty():
+		result["overrides"] = overrides
+
+	return result
+
+
+## Every setting whose name starts with [param prefix], with the type the engine registers for
+## each.
+##
+## The type is here because it is the half a name hides. A setting sitting among a family of levels
+## can be a bool, and a caller that assumes otherwise writes a level over it and sees nothing go
+## wrong: 2 is as true as true is.
+static func under(prefix: String, values: GdhSerialisation) -> Dictionary:
+	var found: Array[Dictionary] = []
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(property.get("name", ""))
+		if not name.begins_with(prefix):
+			continue
+		var kind: int = GdhRead.as_int(property.get("type", TYPE_NIL), TYPE_NIL)
+		var value: Variant = ProjectSettings.get_setting(name)
+		var described: Dictionary = {
+			"setting": name,
+			"type": type_string(kind),
+			"value": values.serialize_value(value),
+		}
+		# As a single get says it, so a family read can be told apart into what the project sets
+		# and the engine's defaults: "input/" is ninety actions the engine ships and the project's few.
+		var default_value: Variant = ProjectSettings.property_get_revert(name)
+		if default_value != null:
+			described["at_default"] = value == default_value
+		var base: String = override_base(name)
+		if not base.is_empty():
+			described["override_of"] = base
+		found.append(described)
+
+	found.sort_custom(func(a: Dictionary, b: Dictionary) -> bool: return a["setting"] < b["setting"])
+	return {"prefix": prefix, "count": found.size(), "settings": found}
+
+
+## The setting [param setting_path] overrides for builds with one feature, as
+## `application/run/max_fps.mobile` does `application/run/max_fps`, or "" for a plain setting.
+static func override_base(setting_path: String) -> String:
+	var dot: int = setting_path.find(".", setting_path.rfind("/") + 1)
+	return "" if dot == -1 else setting_path.substr(0, dot)
+
+
+## The overrides project.godot sets for [param setting_path], by feature.
+static func overrides_of(setting_path: String, values: GdhSerialisation) -> Dictionary:
+	var overrides: Dictionary = {}
+	for info: Dictionary in ProjectSettings.get_property_list():
+		var name: String = str(info.get("name", ""))
+		if name.begins_with(setting_path + "."):
+			overrides[name.substr(setting_path.length() + 1)] = values.serialize_value(
+				ProjectSettings.get_setting(name)
+			)
+	return overrides
+
+
+## What a build with the feature of [param setting_path], an override project.godot does not set,
+## reads in its place.
+static func overridden_by_none(setting_path: String, values: GdhSerialisation) -> String:
+	var base: String = override_base(setting_path)
+	var feature: String = setting_path.substr(base.length() + 1)
+	var said: String = (
+		(
+			"project.godot sets no %s override of %s, so a build with the %s feature reads %s, "
+			+ "the value under holds"
+		)
+		% [feature, base, feature, base]
+	)
+	var others: Array[String] = []
+	for name: String in overrides_of(base, values).keys():
+		if name != feature:
+			others.append(name)
+	if others.is_empty():
+		return said + "."
+	others.sort()
+	return said + (", unless it also has a feature with an override: %s." % ", ".join(others))

package/build/godot/addons/gdharness_editor/setting_reads.gd.uid

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

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

@@ -5,10 +5,14 @@ extends Node
 ## preloaded rather than looked up on disk at runtime, so a missing one fails to parse here
 ## instead of leaving a command silently unanswered.
 
+const GdhSceneFile = preload("scene_file.gd")
 const GdhSceneTools = preload("tools/scene_tools.gd")
 const GdhSignalTools = preload("tools/signal_tools.gd")
 const GdhResourceTools = preload("tools/resource_tools.gd")
+const GdhTilesetTools = preload("tools/tileset_tools.gd")
+const GdhAnimationStates = preload("tools/animation_states.gd")
 const GdhAnimationTools = preload("tools/animation_tools.gd")
+const GdhAnimationTracks = preload("tools/animation_tracks.gd")
 const GdhPlayTools = preload("tools/play_tools.gd")
 const GdhClassTools = preload("tools/class_tools.gd")
 const GdhSettingsTools = preload("tools/settings_tools.gd")
@@ -20,7 +24,10 @@ var _editor_plugin: EditorPlugin = null
 var _scene_tools: GdhSceneTools = null
 var _signal_tools: GdhSignalTools = null
 var _resource_tools: GdhResourceTools = null
+var _tileset_tools: GdhTilesetTools = null
+var _animation_states: GdhAnimationStates = null
 var _animation_tools: GdhAnimationTools = null
+var _animation_tracks: GdhAnimationTracks = null
 var _play_tools: GdhPlayTools = null
 var _class_tools: GdhClassTools = null
 var _settings_tools: GdhSettingsTools = null
@@ -36,7 +43,10 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_init_tools()
 	_scene_tools.set_editor_plugin(plugin)
 	_resource_tools.set_editor_plugin(plugin)
+	_tileset_tools.set_editor_plugin(plugin)
 	_animation_tools.set_editor_plugin(plugin)
+	_animation_states.set_editor_plugin(plugin)
+	_animation_tracks.set_editor_plugin(plugin)
 	_play_tools.set_editor_plugin(plugin)
 	_class_tools.set_editor_plugin(plugin)
 	_filesystem_tools.set_editor_plugin(plugin)
@@ -60,10 +70,22 @@ func _init_tools() -> void:
 	_resource_tools.name = "ResourceTools"
 	add_child(_resource_tools)
 
+	_tileset_tools = GdhTilesetTools.new()
+	_tileset_tools.name = "TilesetTools"
+	add_child(_tileset_tools)
+
 	_animation_tools = GdhAnimationTools.new()
 	_animation_tools.name = "AnimationTools"
 	add_child(_animation_tools)
 
+	_animation_states = GdhAnimationStates.new()
+	_animation_states.name = "AnimationStates"
+	add_child(_animation_states)
+
+	_animation_tracks = GdhAnimationTracks.new()
+	_animation_tracks.name = "AnimationTracks"
+	add_child(_animation_tracks)
+
 	_play_tools = GdhPlayTools.new()
 	_play_tools.name = "PlayTools"
 	add_child(_play_tools)
@@ -94,6 +116,7 @@ func _init_tools() -> void:
 		"reparent_node": [_scene_tools, "reparent_node"],
 		"set_node_properties": [_scene_tools, "set_node_properties"],
 		"get_node_properties": [_scene_tools, "get_node_properties"],
+		"bake_navigation": [_scene_tools, "bake_navigation"],
 		"save_scene": [_scene_tools, "save_scene"],
 		"connect_signal": [_signal_tools, "connect_signal"],
 		"disconnect_signal": [_signal_tools, "disconnect_signal"],
@@ -104,6 +127,7 @@ func _init_tools() -> void:
 		"files_moved": [_filesystem_tools, "files_moved"],
 		"global_classes": [_class_tools, "global_classes"],
 		"reload_script": [_class_tools, "reload_script"],
+		"scripts_behind": [_class_tools, "scripts_behind"],
 		# Settings, for a caller that asked the editor rather than the file on disk
 		"get_project_setting": [_settings_tools, "get_project_setting"],
 		"adopt_project_settings": [_settings_tools, "adopt_project_settings"],
@@ -113,10 +137,11 @@ func _init_tools() -> void:
 		"modify_resource": [_resource_tools, "modify_resource"],
 		"read_resource": [_resource_tools, "read_resource"],
 		"create_shader": [_resource_tools, "create_shader"],
-		"create_tileset": [_resource_tools, "create_tileset"],
-		"set_tilemap_cells": [_resource_tools, "set_tilemap_cells"],
+		"create_tileset": [_tileset_tools, "create_tileset"],
+		"set_tilemap_cells": [_tileset_tools, "set_tilemap_cells"],
 		"set_theme_color": [_resource_tools, "set_theme_color"],
 		"set_theme_font_size": [_resource_tools, "set_theme_font_size"],
+		"remove_theme_item": [_resource_tools, "remove_theme_item"],
 		"play_scene": [_play_tools, "play_scene"],
 		"restart_editor": [_play_tools, "restart_editor"],
 		"quit_editor": [_play_tools, "quit_editor"],
@@ -130,12 +155,15 @@ func _init_tools() -> void:
 		"read_animations": [_animation_tools, "read_animations"],
 		"read_animation_states": [_animation_tools, "read_animation_states"],
 		"create_animation": [_animation_tools, "create_animation"],
-		"add_animation_track": [_animation_tools, "add_animation_track"],
+		"add_animation_track": [_animation_tracks, "add_animation_track"],
+		"remove_animation_track": [_animation_tracks, "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"],
 	}
 
 
@@ -150,8 +178,13 @@ func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 	if not node.has_method(method):
 		return {"ok": false, "error": "Tool method not found: %s.%s" % [node.name, method]}
 
+	GdhSceneFile.also_saved.clear()
 	var result: Variant = node.call(method, args)
 	if result is Dictionary:
-		return result
+		var answered: Dictionary = result
+		if not GdhSceneFile.also_saved.is_empty():
+			answered["alsoSaved"] = GdhSceneFile.also_saved.duplicate(true)
+			GdhSceneFile.also_saved.clear()
+		return answered
 
 	return {"ok": false, "error": "Invalid tool result from: " + tool_name}

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

@@ -0,0 +1,263 @@
+@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"] = GdhAnimationReads.missing_animation(
+			player, scene.path_of(player), animation_name
+		)
+	var files: Dictionary = machine[2]
+	return _finish(scene, Callable(), files, answer)
+
+
+# =============================================================================
+# 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", ""))
+	# Auto where it is the only mode that does what was asked: a condition is checked only on an auto
+	# transition, and a machine leaves Start only through one. Written as the default enabled, both
+	# did nothing, and the machine sat in Start with its conditions true.
+	var auto: bool = not advance_condition.is_empty() or from_state == "Start"
+	var advance_mode: String = str(args.get("advanceMode", "auto" if auto else "enabled"))
+
+	if from_state.is_empty() or to_state.is_empty():
+		return {"ok": false, "error": "Missing fromState or toState"}
+	var advances: Dictionary = {
+		"auto": AnimationNodeStateMachineTransition.ADVANCE_MODE_AUTO,
+		"enabled": AnimationNodeStateMachineTransition.ADVANCE_MODE_ENABLED,
+		"disabled": AnimationNodeStateMachineTransition.ADVANCE_MODE_DISABLED,
+	}
+	if not advances.has(advance_mode):
+		return {
+			"ok": false,
+			"error": "Unsupported advanceMode: %s; it is auto, enabled or disabled" % advance_mode
+		}
+	if not advance_condition.is_empty() and advance_mode != "auto":
+		return {
+			"ok": false,
+			"error":
+			(
+				(
+					"advanceCondition %s would never advance a transition whose advanceMode is %s: the engine"
+					+ " checks a condition only on an auto one. Leave advanceMode out, or give auto"
+				)
+				% [advance_condition, advance_mode]
+			)
+		}
+	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
+	)
+	transition.advance_mode = (
+		GdhRead.as_int(advances[advance_mode]) as AnimationNodeStateMachineTransition.AdvanceMode
+	)
+	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, "advanceMode": advance_mode}
+	)
+
+
+## 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