gdharness 1.2.33 → 1.2.35

package/build/godot/operations/export_presets.gd

@@ -0,0 +1,232 @@
+extends RefCounted
+
+## export_presets.cfg, read and written in the format the editor's Project > Export saves it in.
+
+const Read = preload("reading.gd")
+const Log = preload("logger.gd")
+
+const PRESETS_FILE: String = "res://export_presets.cfg"
+## Where the editor names the one preset of each platform it runs on a device.
+const RUNNABLE_SECTION: String = "runnable_presets"
+## The platforms the editor's exporter offers, by the name a preset gives its platform, each with
+## how the names of its files in the export templates directory begin.
+const PLATFORMS: Dictionary[String, String] = {
+	"Windows Desktop": "windows_",
+	"Linux": "linux_",
+	"macOS": "macos",
+	"Android": "android_",
+	"iOS": "ios",
+	"Web": "web_",
+}
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+## The names of the project's export presets, in the order export_presets.cfg holds them.
+static func names() -> Array[String]:
+	var named: Array[String] = []
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(PRESETS_FILE) != OK:
+		return named
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		named.append(str(config.get_value("preset." + str(index), "name", "")))
+		index += 1
+	return named
+
+
+func list_export_presets(_params: Dictionary) -> Dictionary:
+	if not FileAccess.file_exists(PRESETS_FILE):
+		return {
+			"presets": [],
+			"presets_file_exists": false,
+			"note":
+			(
+				"No export_presets.cfg found. project_export add_preset adds a preset, as the editor's "
+				+ "Project > Export does."
+			)
+		}
+	var config: ConfigFile = ConfigFile.new()
+	var err: Error = config.load(PRESETS_FILE)
+	if err != OK:
+		return _log.failure("Failed to parse export_presets.cfg: " + error_string(err))
+
+	var templates: String = _templates_dir()
+	var presets: Array[Dictionary] = []
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		var section: String = "preset." + str(index)
+		var platform: String = str(config.get_value(section, "platform", "Unknown"))
+		var preset: Dictionary = {
+			"index": index,
+			"name": config.get_value(section, "name", "Unknown"),
+			"platform": platform,
+			"runnable": _runnable(config, section),
+			"export_path": config.get_value(section, "export_path", ""),
+			"export_filter": config.get_value(section, "export_filter", "all_resources"),
+			"include_filter": config.get_value(section, "include_filter", ""),
+			"exclude_filter": config.get_value(section, "exclude_filter", "")
+		}
+		if config.has_section_key(section, "custom_features"):
+			preset["custom_features"] = config.get_value(section, "custom_features", "")
+		# Left out for a platform this file names and the exporter does not know, which has no
+		# templates to look for.
+		if platform in PLATFORMS:
+			preset["templates_installed"] = _installed(templates, platform)
+		presets.append(preset)
+		index += 1
+	return {"presets": presets, "presets_file_exists": true, "total_presets": index, "templates": templates}
+
+
+## Whether the preset in [param section] is the one its platform runs. The editor names that preset
+## in a section of its own, and kept a key in the preset's section only in files saved before that.
+static func _runnable(config: ConfigFile, section: String) -> bool:
+	var platform: String = str(config.get_value(section, "platform", ""))
+	if config.has_section_key(RUNNABLE_SECTION, platform):
+		return str(config.get_value(RUNNABLE_SECTION, platform)) == str(config.get_value(section, "name", ""))
+	return Read.as_bool(config.get_value(section, "runnable", false))
+
+
+## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
+## writes for a new one. The editor's exporter fills every platform option the file leaves out with
+## its default when it loads the file, which is what a preset fresh from that dialog holds too.
+func add_export_preset(params: Dictionary) -> Dictionary:
+	var preset_name: String = str(params.get("preset", "")).strip_edges()
+	var platform: String = str(params.get("platform", ""))
+	var export_path: String = str(params.get("output_path", "")).trim_prefix("res://")
+	if preset_name.is_empty():
+		return _log.failure("preset is required: the name the preset is exported by")
+	if platform not in PLATFORMS:
+		return _log.failure(
+			"Unknown platform '%s'. The platforms are %s." % [platform, ", ".join(PLATFORMS.keys())]
+		)
+	var config: ConfigFile = ConfigFile.new()
+	if FileAccess.file_exists(PRESETS_FILE):
+		var loading: Error = config.load(PRESETS_FILE)
+		if loading != OK:
+			return _log.failure("Failed to parse export_presets.cfg: " + error_string(loading))
+	var index: int = 0
+	while config.has_section("preset." + str(index)):
+		var held: String = "preset." + str(index)
+		if str(config.get_value(held, "name", "")) == preset_name:
+			return _log.failure(
+				(
+					(
+						"There is already an export preset named '%s', for %s, exporting to '%s'. "
+						+ "project_export run exports with it; give another name to add a second."
+					)
+					% [
+						preset_name,
+						config.get_value(held, "platform", ""),
+						config.get_value(held, "export_path", "")
+					]
+				)
+			)
+		index += 1
+	# A platform with no preset to run takes the new one, as the editor's dialog does.
+	var runnable: bool = not config.has_section_key(RUNNABLE_SECTION, platform)
+	if runnable:
+		config.set_value(RUNNABLE_SECTION, platform, preset_name)
+
+	var section: String = "preset." + str(index)
+	var values: Dictionary = {
+		"name": preset_name,
+		"platform": platform,
+		"dedicated_server": false,
+		"custom_features": "",
+		"export_filter": "all_resources",
+		"include_filter": "",
+		"exclude_filter": "",
+		"export_path": export_path,
+		"patches": PackedStringArray(),
+		"encryption_include_filters": "",
+		"encryption_exclude_filters": "",
+		"seed": 0,
+		"encrypt_pck": false,
+		"encrypt_directory": false,
+		"script_export_mode": 2,
+	}
+	for key: String in values:
+		config.set_value(section, key, values[key])
+	# A section with nothing in it is not written, and the editor's loader reports a missing options
+	# section as an error; these two are options of every platform, empty in a new preset.
+	config.set_value(section + ".options", "custom_template/debug", "")
+	config.set_value(section + ".options", "custom_template/release", "")
+	var saving: Error = config.save(PRESETS_FILE)
+	if saving != OK:
+		return _log.failure("Failed to save export_presets.cfg: " + error_string(saving))
+
+	var templates: String = _templates_dir()
+	var installed: bool = _installed(templates, platform)
+	var answer: Dictionary = {
+		"preset": preset_name,
+		"platform": platform,
+		"index": index,
+		"runnable": runnable,
+		"export_path": export_path,
+		"file": PRESETS_FILE,
+		"templates": templates,
+		"templates_installed": installed,
+	}
+	if not installed:
+		answer["templates_note"] = (
+			(
+				"No %s export templates for this engine are at %s, and an export for %s needs them. The "
+				+ "editor installs them in Editor > Manage Export Templates, or they can be unpacked "
+				+ "there from the export templates archive of this engine's release."
+			)
+			% [platform, templates, platform]
+		)
+	return answer
+
+
+## Where the editor of this engine keeps its export templates: beside the executable for a
+## self-contained one, otherwise in the user's data directory, as the editor's own paths have it.
+static func _templates_dir() -> String:
+	var version: Dictionary = Engine.get_version_info()
+	var named: String = "%d.%d" % [Read.as_int(version.get("major", 0)), Read.as_int(version.get("minor", 0))]
+	if Read.as_int(version.get("patch", 0)) != 0:
+		named += "." + str(Read.as_int(version.get("patch", 0)))
+	named += "." + str(version.get("status", ""))
+	if ClassDB.class_exists("CSharpScript"):
+		named += ".mono"
+	var beside: String = OS.get_executable_path().get_base_dir()
+	var contained: bool = _marks_self_contained(beside)
+	# A macOS bundle is read-only, so its editor looks for the marker beside the bundle too, and keeps
+	# its data there whichever of the two places had it.
+	if (
+		OS.has_feature("macos")
+		and beside.ends_with("MacOS")
+		and beside.path_join("..").simplify_path().ends_with("Contents")
+	):
+		beside = beside.path_join("../../..").simplify_path()
+		contained = contained or _marks_self_contained(beside)
+	if contained:
+		return beside.path_join("editor_data").path_join("export_templates").path_join(named)
+	var home: String = (
+		"godot" if OS.get_name() in ["Linux", "FreeBSD", "NetBSD", "OpenBSD", "BSD"] else "Godot"
+	)
+	return OS.get_data_dir().path_join(home).path_join("export_templates").path_join(named)
+
+
+## Whether [param templates] holds any of [param platform]'s templates. The directory is one per
+## engine version and holds whichever platforms were installed into it, so its being there says
+## nothing about this platform.
+static func _installed(templates: String, platform: String) -> bool:
+	if not DirAccess.dir_exists_absolute(templates):
+		return false
+	for file: String in DirAccess.get_files_at(templates):
+		if file.begins_with(PLATFORMS[platform]):
+			return true
+	return false
+
+
+static func _marks_self_contained(directory: String) -> bool:
+	return (
+		FileAccess.file_exists(directory.path_join("._sc_"))
+		or FileAccess.file_exists(directory.path_join("_sc_"))
+	)

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,10 +14,12 @@ 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")
 const Dependencies = preload("dependencies.gd")
+const ExportPresets = preload("export_presets.gd")
 const FileReads = preload("file_reads.gd")
 const GdscriptAnalysis = preload("gdscript_analysis.gd")
 const GdscriptAuthoring = preload("gdscript_authoring.gd")
@@ -153,6 +155,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":
@@ -162,7 +180,9 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 		"set_import_options":
 			payload = ImportPipeline.new(_log).set_import_options(params)
 		"list_export_presets":
-			payload = ImportPipeline.new(_log).list_export_presets(params)
+			payload = ExportPresets.new(_log).list_export_presets(params)
+		"add_export_preset":
+			payload = ExportPresets.new(_log).add_export_preset(params)
 		"validate_project":
 			payload = ImportPipeline.new(_log).validate_project(params)
 

package/build/godot/operations/import_pipeline.gd

@@ -1,5 +1,6 @@
 extends RefCounted
 
+const ExportPresets = preload("export_presets.gd")
 const Read = preload("reading.gd")
 const Serialisation = preload("serialisation.gd")
 const FileWalk = preload("file_walk.gd")
@@ -319,63 +320,6 @@ static func _all_ints(held: Variant, keys: bool) -> bool:
 	return true
 
 
-# The names of the project's export presets, in the order export_presets.cfg holds them.
-static func _preset_names() -> Array[String]:
-	var names: Array[String] = []
-	var config: ConfigFile = ConfigFile.new()
-	if config.load("res://export_presets.cfg") != OK:
-		return names
-	var index: int = 0
-	while config.has_section("preset." + str(index)):
-		names.append(str(config.get_value("preset." + str(index), "name", "")))
-		index += 1
-	return names
-
-
-# List export presets
-func list_export_presets(_params: Dictionary) -> Dictionary:
-	_log.info("Listing export presets")
-
-	var presets_file: String = "res://export_presets.cfg"
-
-	if not FileAccess.file_exists(presets_file):
-		return {
-			"presets": [],
-			"presets_file_exists": false,
-			"note": "No export_presets.cfg found. Configure export presets in the Godot editor."
-		}
-
-	var config: ConfigFile = ConfigFile.new()
-	var err: Error = config.load(presets_file)
-
-	if err != OK:
-		return _log.failure("Failed to parse export_presets.cfg: " + str(err))
-
-	# Export presets are stored as [preset.0], [preset.1], etc.
-	var presets: Array[Dictionary] = []
-	var preset_idx: int = 0
-	while config.has_section("preset." + str(preset_idx)):
-		var section: String = "preset." + str(preset_idx)
-		var preset: Dictionary = {
-			"index": preset_idx,
-			"name": config.get_value(section, "name", "Unknown"),
-			"platform": config.get_value(section, "platform", "Unknown"),
-			"runnable": config.get_value(section, "runnable", false),
-			"export_path": config.get_value(section, "export_path", ""),
-			"export_filter": config.get_value(section, "export_filter", "all_resources"),
-			"include_filter": config.get_value(section, "include_filter", ""),
-			"exclude_filter": config.get_value(section, "exclude_filter", "")
-		}
-
-		if config.has_section_key(section, "custom_features"):
-			preset["custom_features"] = config.get_value(section, "custom_features", "")
-
-		presets.append(preset)
-		preset_idx += 1
-
-	return {"presets": presets, "presets_file_exists": true, "total_presets": preset_idx}
-
-
 # Validate project for export
 func validate_project(params: Dictionary) -> Dictionary:
 	var preset_name: String = str(params.get("preset", ""))
@@ -429,7 +373,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 				"warning",
 				"export_presets",
 				"No export presets configured",
-				"Configure export presets in Godot editor: Project > Export",
+				"Add a preset with project_export add_preset, or in the editor: Project > Export",
 				include_suggestions
 			)
 		)
@@ -438,7 +382,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 	# does not exist answered valid, as though it had been checked.
 	if not preset_name.is_empty():
 		checks_performed.append("export_preset")
-		var named: Array[String] = _preset_names()
+		var named: Array[String] = ExportPresets.names()
 		if preset_name not in named:
 			issues.append(
 				_finding(
@@ -453,7 +397,7 @@ func validate_project(params: Dictionary) -> Dictionary:
 							else ": the presets are " + ", ".join(named)
 						)
 					),
-					"Pass one of the preset names, or add the preset in the editor: Project > Export",
+					"Pass one of the preset names, or add the preset with project_export add_preset",
 					include_suggestions
 				)
 			)

package/build/godot/operations/input_actions.gd

@@ -170,19 +170,63 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	if action.is_empty():
 		return {}
 
+	# An action that exists is rebound, which is how one of the engine's ui_ actions is changed, so
+	# what it held is answered rather than lost without a word.
+	var setting: String = "input/" + action_name
+	var answer: Dictionary = {
+		"action_name": action_name,
+		"events_count": events_config.size(),
+		"deadzone": deadzone,
+		"events": events_config,
+		"was_new": not ProjectSettings.has_setting(setting),
+	}
+	if not answer["was_new"]:
+		var held: Variant = ProjectSettings.get_setting(setting)
+		var old: Dictionary = held if held is Dictionary else {}
+		var old_events: Array[Dictionary] = []
+		var listed: Variant = old.get("events", [])
+		if listed is Array:
+			var events_held: Array = listed
+			for event: Variant in events_held:
+				if event is InputEvent:
+					var bound: InputEvent = event
+					old_events.append(_shaped(bound))
+		answer["old_events"] = old_events
+		answer["old_deadzone"] = Read.as_float(old.get("deadzone", 0.5), 0.5)
+
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
-	ProjectSettings.set_setting("input/" + action_name, action)
+	ProjectSettings.set_setting(setting, action)
 	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {
-		"action_name": action_name,
-		"events_count": events_config.size(),
-		"deadzone": deadzone,
-		"events": events_config
-	}
+	return answer
+
+
+## [param event] in the form add_input_action answers its events with, and as the engine names it
+## under text, which also covers a kind of event that form has no fields for.
+static func _shaped(event: InputEvent) -> Dictionary:
+	var shaped: Dictionary = {"class_name": event.get_class(), "text": event.as_text()}
+	if event is InputEventKey:
+		var key: InputEventKey = event
+		shaped["keycode"] = key.keycode
+		if key.physical_keycode != KEY_NONE:
+			shaped["physical_keycode"] = key.physical_keycode
+		for modifier: String in ["ctrl_pressed", "alt_pressed", "shift_pressed"]:
+			if key.get(modifier):
+				shaped[modifier] = true
+	elif event is InputEventMouseButton:
+		var mouse: InputEventMouseButton = event
+		shaped["button_index"] = mouse.button_index
+	elif event is InputEventJoypadButton:
+		var pad: InputEventJoypadButton = event
+		shaped["button_index"] = pad.button_index
+	elif event is InputEventJoypadMotion:
+		var motion: InputEventJoypadMotion = event
+		shaped["axis"] = motion.axis
+		shaped["axis_value"] = motion.axis_value
+	return shaped
 
 
 # Remove an input action the project defines, which add_input_action had no way back from.

package/build/godot/operations/project_diagnostics.gd

@@ -148,7 +148,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		recommendations.append("Address critical issues to improve project stability")
 	# A project still being made has no presets yet, which is no fault in it.
 	if "config" in check_categories and not FileAccess.file_exists("res://export_presets.cfg"):
-		recommendations.append("No export presets are configured: add them before exporting")
+		recommendations.append(
+			"No export presets are configured: project_export add_preset adds one before exporting"
+		)
 
 	# Every detail costs points, so each is an issue; `issues` was always empty beside them, and a
 	# category said passed next to the failure it had just found.