gdharness 1.2.14 → 1.2.16

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

@@ -17,6 +17,16 @@ extends RefCounted
 const Read = preload("reading.gd")
 const Serialisation = preload("serialisation.gd")
 
+# The data types a Theme names its items by, as in "Button/colors/font_color", and what each holds.
+const THEME_ITEMS: Dictionary[String, Array] = {
+	"colors": [TYPE_COLOR, ""],
+	"constants": [TYPE_INT, ""],
+	"font_sizes": [TYPE_INT, ""],
+	"fonts": [TYPE_OBJECT, "Font"],
+	"icons": [TYPE_OBJECT, "Texture2D"],
+	"styles": [TYPE_OBJECT, "StyleBox"],
+}
+
 # What each packed array holds, for the four whose elements are not types JSON has. A polygon is
 # written as a list of pairs, and only the property knows that each pair is a Vector2 rather than a
 # list of two numbers: without being told, every element was read as itself and the engine turned
@@ -394,9 +404,27 @@ func declaration(target: Object, property: String) -> Dictionary:
 		if Read.as_int(declared.get("usage", 0)) & HEADINGS:
 			continue
 		return declared
+	if target is Theme:
+		return _theme_item(property)
 	return {}
 
 
+## The entry a Theme would declare for [param property] once it held that item, or {} when the name
+## is not an item's. A Theme lists only the items it holds and takes any other through set, so an
+## item a read of one theme answered with was refused when written into another that lacked it.
+static func _theme_item(property: String) -> Dictionary:
+	var parts: PackedStringArray = property.split("/")
+	if parts.size() != 3 or parts[0].is_empty() or parts[2].is_empty() or not THEME_ITEMS.has(parts[1]):
+		return {}
+	var item: Array = THEME_ITEMS[parts[1]]
+	var kind: int = item[0]
+	var made: Dictionary = {"name": property, "type": kind, "usage": PROPERTY_USAGE_DEFAULT}
+	if kind == TYPE_OBJECT:
+		made["hint"] = PROPERTY_HINT_RESOURCE_TYPE
+		made["hint_string"] = item[1]
+	return made
+
+
 ## Whether [param held] is [param given], as a property read back after a set answers it.
 ##
 ## Close enough rather than equal for anything made of floats: a Vector2 property stores 32-bit

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

@@ -124,21 +124,40 @@ func fixed(node: Node) -> String:
 	return ""
 
 
-## Why [param child_name] cannot be given to a child of [param parent], or "". Godot renames a node
-## whose name is taken or holds a character a path cannot, and the next call naming it would then
-## reach another node.
-func unusable_name(parent: Node, child_name: String, moving: Node = null) -> String:
-	if child_name.is_empty():
+## Why the folder a new file at [param file_path] goes in cannot be made, or "" once it is there. The
+## engine makes no folder when it saves, so a create into one not yet made failed with no more than
+## the engine's error, while script_edit create made its folder and went ahead.
+static func make_folder_for(file_path: String) -> String:
+	var folder: String = file_path.get_base_dir()
+	if DirAccess.dir_exists_absolute(folder):
+		return ""
+	var made: Error = DirAccess.make_dir_recursive_absolute(folder)
+	return "" if made == OK else "Could not make the folder %s: %s" % [folder, error_string(made)]
+
+
+## Why no node can be called [param node_name], wherever it sits, or "".
+static func unfit_name(node_name: String) -> String:
+	if node_name.is_empty():
 		return "A node needs a name."
-	var valid: String = child_name.validate_node_name()
-	if valid != child_name:
+	var valid: String = node_name.validate_node_name()
+	if valid != node_name:
 		return (
 			(
 				"%s is not a name a node can have; Godot would save it as %s. The characters "
 				+ '. : @ / " %% cannot be in a node name.'
 			)
-			% [child_name, valid]
+			% [node_name, valid]
 		)
+	return ""
+
+
+## Why [param child_name] cannot be given to a child of [param parent], or "". Godot renames a node
+## whose name is taken or holds a character a path cannot, and the next call naming it would then
+## reach another node.
+func unusable_name(parent: Node, child_name: String, moving: Node = null) -> String:
+	var unfit: String = unfit_name(child_name)
+	if not unfit.is_empty():
+		return unfit
 	var taken: Node = parent.get_node_or_null(NodePath(child_name))
 	if taken != null and taken != moving and taken.get_parent() == parent:
 		return "%s already has a child named %s." % [path_of(parent), child_name]

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

@@ -540,6 +540,9 @@ func _serialize_colors(value: PackedColorArray) -> Array:
 
 # A pathless Resource says so rather than inventing an empty path for the caller to load.
 func _serialize_object(value: Object) -> Variant:
+	if value is InputEvent:
+		var event: InputEvent = value
+		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
 		if resource.resource_path.is_empty():
@@ -552,6 +555,23 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## An input event, by what it is bound to: the engine's own words for it and every field it stores
+## away from its default. As a bare resource it was its class and nothing else, so an input action
+## read back from project.godot could not say whether it was bound to Space or to a joypad button.
+func _describe_input_event(event: InputEvent) -> Dictionary:
+	var described: Dictionary = {"class": event.get_class(), "_type": "Resource", "text": event.as_text()}
+	for property: Dictionary in event.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if not (usage & PROPERTY_USAGE_STORAGE) or name.begins_with("resource_") or name == "script":
+			continue
+		var held: Variant = event.get(name)
+		if held == ClassDB.class_get_property_default_value(event.get_class(), name):
+			continue
+		described[name] = serialize_value(held)
+	return described
+
+
 ## A plain object, said in enough detail to tell it from the one beside it.
 ##
 ## `{"class": "RefCounted"}` was all of it, so a roster of twelve people came back as the word

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

@@ -104,12 +104,12 @@ func _init_tools() -> void:
 		# Resource tools
 		"create_resource": [_resource_tools, "create_resource"],
 		"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"],
 		"set_theme_color": [_resource_tools, "set_theme_color"],
 		"set_theme_font_size": [_resource_tools, "set_theme_font_size"],
-		# Animation tools
 		"play_scene": [_play_tools, "play_scene"],
 		"restart_editor": [_play_tools, "restart_editor"],
 		"quit_editor": [_play_tools, "quit_editor"],
@@ -118,6 +118,9 @@ func _init_tools() -> void:
 		# The script profiler on a game the editor plays
 		"profile_start": [_profile_tools, "profile_start"],
 		"profile_read": [_profile_tools, "profile_read"],
+		# Animation tools
+		"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_state": [_animation_tools, "add_animation_state"],

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

@@ -6,9 +6,33 @@ extends Node
 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",
+}
 
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
+var _values: Serialisation = Serialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -47,6 +71,19 @@ func _open_at(scene_path: String, node_path: String, kind: String) -> Array:
 	return [scene, node, {}]
 
 
+## [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 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("%s not found at: %s" % [kind, node_path])]
+	return [scene, node, {}]
+
+
 ## 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:
@@ -181,6 +218,141 @@ func _animated(player: AnimationPlayer, track_path: String) -> Node:
 	return from.get_node_or_null(NodePath(track_path))
 
 
+# =============================================================================
+# read_animations, read_animation_states
+# =============================================================================
+## The animations of an AnimationPlayer, or one of them whole. A track comes back in the shape
+## add_track takes, so one read here can be written to another animation as it stands.
+func read_animations(args: Dictionary) -> Dictionary:
+	var scene_path: String = _ensure_res_path(str(args.get("scenePath", "")))
+	var player_node_path: String = str(args.get("playerNodePath", "."))
+	var animation_name: String = str(args.get("animationName", ""))
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+
+	var opened: Array = _read_at(scene_path, player_node_path, "AnimationPlayer")
+	var scene: SceneFile = opened[0]
+	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"]
+			)
+		)
+
+	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
+	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", "")))
+	var anim_tree_path: String = str(args.get("animTreePath", ""))
+	var state_machine_path: String = str(args.get("stateMachinePath", ""))
+	if scene_path.strip_edges() == "res://":
+		return {"ok": false, "error": "Missing scenePath"}
+	if anim_tree_path.is_empty():
+		return {"ok": false, "error": "Missing animTreePath"}
+
+	var opened: Array = _read_at(scene_path, anim_tree_path, "AnimationTree")
+	var scene: SceneFile = opened[0]
+	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),
+	}
+
+
 # =============================================================================
 # create_animation
 # =============================================================================

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

@@ -6,51 +6,21 @@ extends Node
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
+const Serialisation = preload("../serialisation.gd")
 
-# Shader templates. Written as real multi-line source rather than escaped one-liners so that
-# what ends up in the .gdshader can be read here. The %s is the shader type.
+# The minimal shader of a type: its declaration and the one function the engine calls for it.
 const SHADER_EMPTY: String = """shader_type %s;
 
-void fragment() {
+void %s() {
 }
 """
-
-const SHADER_BASIC: String = """shader_type %s;
-
-void fragment() {
-	COLOR = vec4(1.0);
-}
-"""
-
-const SHADER_COLOR_SHIFT: String = """shader_type %s;
-
-uniform vec4 color_shift : source_color = vec4(0.1, 0.0, 0.2, 0.0);
-
-void fragment() {
-	vec4 base = texture(TEXTURE, UV);
-	COLOR = vec4(clamp(base.rgb + color_shift.rgb, 0.0, 1.0), base.a);
+const SHADER_ENTRY: Dictionary[String, String] = {
+	"canvas_item": "fragment", "spatial": "fragment", "particles": "process", "sky": "sky", "fog": "fog"
 }
-"""
-
-const SHADER_OUTLINE: String = """shader_type %s;
-
-uniform vec4 outline_color : source_color = vec4(0.0, 0.0, 0.0, 1.0);
-uniform float outline_width : hint_range(0.0, 8.0) = 1.0;
-
-void fragment() {
-	vec2 px = TEXTURE_PIXEL_SIZE * outline_width;
-	float a = texture(TEXTURE, UV).a;
-	float edge = max(
-		max(texture(TEXTURE, UV + vec2(px.x, 0.0)).a, texture(TEXTURE, UV - vec2(px.x, 0.0)).a),
-		max(texture(TEXTURE, UV + vec2(0.0, px.y)).a, texture(TEXTURE, UV - vec2(0.0, px.y)).a)
-	);
-	vec4 base = texture(TEXTURE, UV);
-	COLOR = mix(outline_color * edge, base, a);
-}
-"""
 
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
+var _values: Serialisation = Serialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -217,6 +187,9 @@ func create_resource(args: Dictionary) -> Dictionary:
 	if not refused.is_empty():
 		return {"ok": false, "error": refused}
 
+	var folder: String = SceneFile.make_folder_for(res_path)
+	if not folder.is_empty():
+		return {"ok": false, "error": folder}
 	var failed: String = _save_checked(resource, res_path, properties.keys(), null)
 	if not failed.is_empty():
 		return {"ok": false, "error": failed}
@@ -260,6 +233,50 @@ func modify_resource(args: Dictionary) -> Dictionary:
 	return {"ok": true, "resourcePath": res_path}
 
 
+## 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 the editor's cached copy, since the file is what the other ops
+## write and what the project loads.
+func read_resource(args: Dictionary) -> Dictionary:
+	var res_path: String = _ensure_res_path(str(args.get("resourcePath", "")))
+	var include_defaults: bool = Read.as_bool(args.get("includeDefaults", false))
+	if res_path == "res://":
+		return {"ok": false, "error": "resourcePath is required"}
+	if not FileAccess.file_exists(res_path):
+		return {"ok": false, "error": "No resource at " + res_path}
+	var resource: Resource = ResourceLoader.load(res_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if resource == null:
+		return {"ok": false, "error": "%s did not load as a resource." % res_path}
+
+	var script: Script = resource.get_script()
+	var scripted: Dictionary = {}
+	if script != null:
+		for declared: Dictionary in script.get_script_property_list():
+			scripted[str(declared.get("name", ""))] = true
+	var properties: Dictionary = {}
+	for p: Dictionary in resource.get_property_list():
+		var property: String = str(p.get("name", ""))
+		if property.is_empty() or property == "script":
+			continue
+		if not (Read.as_int(p.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+			continue
+		var value: Variant = resource.get(property)
+		if not include_defaults:
+			var default: Variant = (
+				script.get_property_default_value(property)
+				if scripted.has(property)
+				else ClassDB.class_get_property_default_value(resource.get_class(), property)
+			)
+			if PropertyValues.same(value, default):
+				continue
+		properties[property] = _values.serialize_value(value)
+	var answer: Dictionary = {
+		"ok": true, "resourcePath": res_path, "resourceType": resource.get_class(), "properties": properties
+	}
+	if script != null:
+		answer["script"] = script.resource_path
+	return answer
+
+
 func create_shader(args: Dictionary) -> Dictionary:
 	var shader_path: String = _ensure_res_path(str(args.get("shaderPath", "")))
 	var shader_type: String = str(args.get("shaderType", "canvas_item"))
@@ -270,19 +287,12 @@ func create_shader(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": taken}
 
 	var code: String = str(args.get("code", ""))
-	var template: String = str(args.get("template", ""))
-
 	if code == "":
-		match template:
-			"basic":
-				code = SHADER_BASIC % shader_type
-			"color_shift":
-				code = SHADER_COLOR_SHIFT % shader_type
-			"outline":
-				code = SHADER_OUTLINE % shader_type
-			_:
-				code = SHADER_EMPTY % shader_type
+		code = SHADER_EMPTY % [shader_type, SHADER_ENTRY.get(shader_type, "fragment")]
 
+	var folder: String = SceneFile.make_folder_for(shader_path)
+	if not folder.is_empty():
+		return {"ok": false, "error": folder}
 	var file: FileAccess = FileAccess.open(shader_path, FileAccess.WRITE)
 	if file == null:
 		return {
@@ -335,6 +345,9 @@ func create_tileset(args: Dictionary) -> Dictionary:
 			{"sourceId": added, "texture": atlas.texture.resource_path, "tiles": atlas.get_tiles_count()}
 		)
 
+	var folder: String = SceneFile.make_folder_for(tileset_path)
+	if not folder.is_empty():
+		return {"ok": false, "error": folder}
 	var saving: Error = ResourceSaver.save(tileset, tileset_path)
 	if saving != OK:
 		return {"ok": false, "error": "Failed to save %s: %s" % [tileset_path, error_string(saving)]}

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

@@ -8,6 +8,16 @@ const PropertyValues = preload("../property_values.gd")
 const SceneFile = preload("../scene_file.gd")
 const Serialisation = preload("../serialisation.gd")
 
+## The names Object.ConnectFlags gives each bit. The number alone left a reader guessing that 2 is
+## the persistence every connection in a saved scene carries.
+const CONNECT_FLAG_NAMES: Dictionary[int, String] = {
+	Object.CONNECT_DEFERRED: "deferred",
+	Object.CONNECT_PERSIST: "persist",
+	Object.CONNECT_ONE_SHOT: "one_shot",
+	Object.CONNECT_REFERENCE_COUNTED: "reference_counted",
+	Object.CONNECT_APPEND_SOURCE_OBJECT: "append_source_object",
+}
+
 var _editor_plugin: EditorPlugin = null
 var _values: Serialisation = Serialisation.new()
 var _properties: PropertyValues = PropertyValues.new()
@@ -17,6 +27,19 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
 
 
+## Each bit set in [param flags] by name, and whatever bits are left unnamed as one number.
+static func _flag_names(flags: int) -> Array[String]:
+	var names: Array[String] = []
+	var rest: int = flags
+	for bit: int in CONNECT_FLAG_NAMES:
+		if flags & bit:
+			names.append(CONNECT_FLAG_NAMES[bit])
+			rest &= ~bit
+	if rest != 0:
+		names.append(str(rest))
+	return names
+
+
 func _ensure_res_path(path: String) -> String:
 	if not path.begins_with("res://"):
 		return "res://" + path
@@ -249,7 +272,8 @@ func create_scene(args: Dictionary) -> Dictionary:
 	var project_path: String = str(args.get("projectPath", ""))
 	var scene_path: String = _to_scene_res_path(project_path, str(args.get("scenePath", "")))
 	var root_node_type: String = str(args.get("rootNodeType", "Node"))
-	var script_path: String = str(args.get("scriptPath", ""))
+	var root_node_name: String = str(args.get("rootNodeName", root_node_type))
+	var script_path: String = str(args.get("script", ""))
 
 	if scene_path == "res://":
 		return {"ok": false, "error": "Missing scenePath"}
@@ -263,6 +287,9 @@ func create_scene(args: Dictionary) -> Dictionary:
 		}
 	if not ClassDB.can_instantiate(root_node_type):
 		return {"ok": false, "error": "%s cannot be instantiated." % root_node_type}
+	var unfit: String = SceneFile.unfit_name(root_node_name)
+	if not unfit.is_empty():
+		return {"ok": false, "error": unfit}
 	# Saving over a scene that is there replaced it, nodes and all, and answered as a new scene.
 	if FileAccess.file_exists(scene_path):
 		return {
@@ -278,7 +305,7 @@ func create_scene(args: Dictionary) -> Dictionary:
 		}
 
 	var root: Node = ClassDB.instantiate(root_node_type)
-	root.name = root_node_type
+	root.name = root_node_name
 
 	if not script_path.is_empty():
 		var full_script_path: String = _to_scene_res_path(project_path, script_path)
@@ -296,6 +323,10 @@ func create_scene(args: Dictionary) -> Dictionary:
 			}
 		root.set_script(script)
 
+	var folder: String = SceneFile.make_folder_for(scene_path)
+	if not folder.is_empty():
+		root.free()
+		return {"ok": false, "error": folder}
 	var scene: SceneFile = SceneFile.new()
 	scene.root = root
 	scene.path = scene_path
@@ -303,7 +334,9 @@ func create_scene(args: Dictionary) -> Dictionary:
 	if not written.is_empty():
 		return written
 
-	return {"ok": true, "scenePath": scene_path, "rootNodeType": root_node_type}
+	return {
+		"ok": true, "scenePath": scene_path, "rootNodeType": root_node_type, "rootNodeName": root_node_name
+	}
 
 
 func list_scene_nodes(args: Dictionary) -> Dictionary:
@@ -597,12 +630,19 @@ func get_node_properties(args: Dictionary) -> Dictionary:
 	# names this scene's file sets are always answered.
 	var props: Dictionary = _properties_of(node, include_defaults, scene.set_here(node))
 	scene.close()
-	return {
+	var answer: Dictionary = {
 		"ok": true,
 		"nodePath": node_path,
 		"properties": props,
 		"unsavedInEditor": SceneFile.unsaved(scene_path)
 	}
+	# An empty answer read as a node with nothing on it, rather than one with nothing changed.
+	if props.is_empty() and not include_defaults:
+		answer["note"] = (
+			"Every property of this node is at its default, so none is listed; "
+			+ "includeDefaults: true lists them all."
+		)
+	return answer
 
 
 func save_scene(args: Dictionary) -> Dictionary:
@@ -739,6 +779,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 		"targetNodePath": to,
 		"methodName": method_name,
 		"flags": saved_flags[0],
+		"flagNames": _flag_names(Read.as_int(saved_flags[0])),
 		# Connected either way, as the editor's own dialog allows, since the method may be written
 		# next; a caller told nothing learnt of a misspelt one only when the signal fired.
 		"methodFound": method_found
@@ -894,6 +935,7 @@ func list_connections(args: Dictionary) -> Dictionary:
 							"targetNodePath": target_path,
 							"methodName": str(callable.get_method()),
 							"flags": flags,
+							"flagNames": _flag_names(flags),
 							# False for a connection an instanced scene makes inside itself, which only that
 							# scene can change.
 							"editable": editable

package/build/godot/addons/gdharness_runtime/runtime_capture.gd

@@ -250,14 +250,24 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 	# texture keeps whatever was drawn last. A capture then comes back byte for byte the same
 	# every time, with a success payload, and a game running perfectly well reads as a game
 	# that has frozen. A frame nobody drew is not evidence of anything, so it is refused.
+	# Told apart, because the remedies are: a headless game told to restore its window had none.
+	if DisplayServer.get_name() == "headless":
+		return {
+			"type": "error",
+			"message":
+			(
+				"This game runs headless, so it has no window and draws nothing to capture. Start it "
+				+ "with a window (editor_run start with headless false) to capture it."
+			),
+		}
 	if not _host.get_tree().root.can_draw():
 		return {
 			"type": "error",
 			"message":
 			(
-				"Nothing is being drawn to the game's window: it is minimised, or this engine "
-				+ "has no window. The texture still holds the last frame that was drawn, so this "
-				+ "and every capture after it would be that frame. Restore the window and ask again."
+				"Nothing is being drawn to the game's window because it is minimised. The texture "
+				+ "still holds the last frame that was drawn, so this and every capture after it "
+				+ "would be that frame. Restore the window and ask again."
 			),
 		}