gdharness 1.3.9 → 1.3.11

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

@@ -5,11 +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")
@@ -21,8 +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
@@ -38,8 +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)
@@ -63,6 +70,10 @@ 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)
@@ -71,6 +82,10 @@ func _init_tools() -> void:
 	_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)
@@ -101,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"],
@@ -111,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"],
@@ -120,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"],
@@ -137,8 +155,8 @@ 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"],
-		"remove_animation_track": [_animation_tools, "remove_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"],
@@ -160,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

@@ -58,29 +58,13 @@ func add_animation_state(args: Dictionary) -> Dictionary:
 	# 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)
+		answer["animationMissing"] = GdhAnimationReads.missing_animation(
+			player, scene.path_of(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
 # =============================================================================
@@ -89,9 +73,36 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	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,
@@ -103,6 +114,9 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	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)
 
@@ -119,7 +133,12 @@ func connect_animation_states(args: Dictionary) -> Dictionary:
 	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})
+	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 "".