gdharness 1.2.30 → 1.2.32

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

@@ -1,9 +1,11 @@
 @tool
 extends Node
 
-## The editor's view of the files on disk: scans, the reimports asked for, and where each stands.
+## 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")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -170,6 +172,7 @@ func scan_status(_args: Dictionary) -> Dictionary:
 		"ok": true,
 		"scanning": filesystem.is_scanning(),
 		"importing": filesystem.is_importing(),
+		"pending": SceneFile.scan_due,
 		"sinceScanFinishedMs":
 		-1 if _scan_finished_at_msec < 0 else Time.get_ticks_msec() - _scan_finished_at_msec,
 		"reimportsCompleted": _reimports_completed,
@@ -206,6 +209,66 @@ func reimport_files(args: Dictionary) -> Dictionary:
 	}
 
 
+## Brings the editor up to files moved under it, the way its FileSystem dock brings itself up after
+## a move of its own: each cached resource and each open scene named for where it now is, so what
+## holds them saves the new path, the editor's file list told of both ends, and each open scene that
+## moved or that the move rewrote read again from the file. A scene with unsaved edits is left as it
+## is and named, since reading it again would discard them; its root names the new path either way.
+##
+## A moved tab is read again even when its text did not change: the editor keeps each tab's path
+## twice, on the root and in its own list, and a script can set only the first. The second is what
+## [method EditorInterface.get_open_scenes] answers, and reading the scene again is what writes it.
+func files_moved(args: Dictionary) -> Dictionary:
+	var renames: Dictionary[String, String] = {}
+	var given: Variant = args.get("moved", [])
+	if given is Array:
+		var pairs: Array = given
+		for pair: Variant in pairs:
+			if pair is Dictionary:
+				var named: Dictionary = pair
+				renames[str(named.get("from", ""))] = str(named.get("to", ""))
+	for from: String in renames:
+		if ResourceLoader.has_cached(from):
+			var held: Resource = ResourceLoader.get_cached_ref(from)
+			if held != null:
+				held.take_over_path(renames[from])
+	var dirty: Array[String] = []
+	for path: String in EditorInterface.get_unsaved_scenes():
+		dirty.append(renames.get(path, path))
+	var retargeted: Array[String] = []
+	var reread: Array[String] = []
+	for root: Node in EditorInterface.get_open_scene_roots():
+		var path: String = root.scene_file_path
+		if renames.has(path):
+			root.scene_file_path = renames[path]
+			retargeted.append(path)
+			reread.append(renames[path])
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	for from: String in renames:
+		filesystem.update_file(from)
+		filesystem.update_file(renames[from])
+	var open: Array[String] = []
+	for root: Node in EditorInterface.get_open_scene_roots():
+		open.append(root.scene_file_path)
+	var changed: Variant = args.get("changed", [])
+	if changed is Array:
+		var paths: Array = changed
+		for path: Variant in paths:
+			if open.has(str(path)) and not reread.has(str(path)):
+				reread.append(str(path))
+	var reloaded: Array[String] = []
+	var unsaved: Array[String] = []
+	for scene: String in reread:
+		if dirty.has(scene):
+			unsaved.append(scene)
+		else:
+			EditorInterface.reload_scene_from_path(scene)
+			reloaded.append(scene)
+	reloaded.sort()
+	unsaved.sort()
+	return {"ok": true, "retargetedTabs": retargeted, "reloadedScenes": reloaded, "unsavedScenes": unsaved}
+
+
 func _reimport(paths: PackedStringArray) -> void:
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	# A scan can begin between the answer and this frame, and its import would refuse this one.

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

@@ -3,10 +3,10 @@ extends Node
 
 ## Resource files, shaders, tilesets and themes, written through the open editor.
 
+const FileReads = preload("../file_reads.gd")
 const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 const SceneFile = preload("../scene_file.gd")
-const Serialisation = preload("../serialisation.gd")
 
 # The minimal shader of a type: its declaration and the one function the engine calls for it.
 const SHADER_EMPTY: String = """shader_type %s;
@@ -18,9 +18,11 @@ const SHADER_ENTRY: Dictionary[String, String] = {
 	"canvas_item": "fragment", "spatial": "fragment", "particles": "process", "sky": "sky", "fog": "fog"
 }
 
+## How many cells a read of a tile map lists, enough for a level's worth and not a whole world's.
+const CELLS_SHOWN: int = 1000
+
 var _editor_plugin: EditorPlugin = null
 var _properties: PropertyValues = PropertyValues.new()
-var _values: Serialisation = Serialisation.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -45,7 +47,7 @@ func _written(path: String) -> void:
 	if ResourceLoader.has_cached(path):
 		var _replaced: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)
 	if _editor_plugin:
-		EditorInterface.get_resource_filesystem().scan()
+		SceneFile.scan_later()
 
 
 ## Why a tool that creates [param path] must not write there, or "". Saving over a file that was
@@ -126,8 +128,8 @@ func _save_checked(resource: Resource, path: String, names: Array, previous: Var
 	else:
 		for key: Variant in names:
 			var property: String = str(key)
-			var read: Variant = loaded.get(property)
-			if not PropertyValues.same(read, resource.get(property)):
+			var read: Variant = _properties.read_at(loaded, property)
+			if not PropertyValues.same(read, _properties.read_at(resource, property)):
 				lost = (
 					(
 						"%s.%s would load from the file as %s: it is not a property the file keeps, so "
@@ -236,48 +238,12 @@ 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.
+## What a resource file holds, read as a headless engine reads it with no editor connected.
 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
+	return FileReads.resource(res_path, Read.as_bool(args.get("includeDefaults", false)))
 
 
 func create_shader(args: Dictionary) -> Dictionary:
@@ -552,7 +518,13 @@ func _cell(entry: Variant, index: int, tile_set: TileSet) -> Array:
 	var atlas_coords: Vector2i = atlas_at[1]
 	var alternative: int = Read.as_int(cell.get("alternativeTile", 0))
 	if not source.has_tile(atlas_coords):
-		return [false, "Source %d has no tile at %s" % [source_id, atlas_coords]]
+		return [
+			false,
+			(
+				"cells[%d]: source %d has no tile at %s; it has %s. Nothing was placed."
+				% [index, source_id, atlas_coords, _tiles_of(source)]
+			)
+		]
 	if not source.has_alternative_tile(atlas_coords, alternative):
 		return [
 			false,
@@ -561,6 +533,72 @@ func _cell(entry: Variant, index: int, tile_set: TileSet) -> Array:
 	return [true, at[1], source_id, atlas_coords, alternative]
 
 
+## The atlas coordinates [param source] has tiles at, the first twelve and how many more, or that it
+## has none: a refusal naming the one missing sent a caller guessing which of the others exist.
+static func _tiles_of(source: TileSetSource) -> String:
+	var count: int = source.get_tiles_count()
+	if count == 0:
+		return "no tiles"
+	var named: Array[String] = []
+	for index: int in mini(count, 12):
+		named.append(str(source.get_tile_id(index)))
+	var more: String = "" if count <= 12 else " and %d more" % (count - 12)
+	return "tiles at " + ", ".join(PackedStringArray(named)) + more
+
+
+## The cells a TileMapLayer or a TileMap holds, as {"cellCount", "cells"} in the form
+## set_tilemap_cells takes, or {} for any other node. The scene keeps them as packed bytes, which a
+## read answered with and nobody could read: a probe counted three cells by decoding the base64 by
+## hand. At most CELLS_SHOWN are listed, the count saying how many there are.
+static func cells_of(node: Node) -> Dictionary:
+	var listed: Array[Dictionary] = []
+	var count: int = 0
+	var single: TileMapLayer = node as TileMapLayer
+	var layered: TileMap = node as TileMap
+	if single != null:
+		var used: Array[Vector2i] = single.get_used_cells()
+		count = used.size()
+		for at: Vector2i in used.slice(0, CELLS_SHOWN):
+			listed.append(
+				_cell_entry(
+					at,
+					single.get_cell_source_id(at),
+					single.get_cell_atlas_coords(at),
+					single.get_cell_alternative_tile(at)
+				)
+			)
+	elif layered != null:
+		for layer: int in layered.get_layers_count():
+			var used: Array[Vector2i] = layered.get_used_cells(layer)
+			count += used.size()
+			for at: Vector2i in used:
+				if listed.size() >= CELLS_SHOWN:
+					break
+				var entry: Dictionary = _cell_entry(
+					at,
+					layered.get_cell_source_id(layer, at),
+					layered.get_cell_atlas_coords(layer, at),
+					layered.get_cell_alternative_tile(layer, at)
+				)
+				entry["layer"] = layer
+				listed.append(entry)
+	else:
+		return {}
+	var answer: Dictionary = {"cellCount": count, "cells": listed}
+	if count > listed.size():
+		answer["cellsNote"] = "The first %d of %d cells are listed." % [listed.size(), count]
+	return answer
+
+
+static func _cell_entry(at: Vector2i, source_id: int, atlas: Vector2i, alternative: int) -> Dictionary:
+	return {
+		"coords": {"x": at.x, "y": at.y},
+		"sourceId": source_id,
+		"atlasCoords": {"x": atlas.x, "y": atlas.y},
+		"alternativeTile": alternative,
+	}
+
+
 func _cell_at(node: Node, layer: int, at: Vector2i) -> Array:
 	var layered: TileMap = node as TileMap
 	if layered != null:

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

@@ -0,0 +1,178 @@
+@tool
+extends RefCounted
+
+## What a new node in a scene is made or copied from, what the scene owns of it, and where among its
+## siblings a node may go.
+
+const Read = preload("../reading.gd")
+const PropertyValues = preload("../property_values.gd")
+
+
+## The scene to instance for an add, or null for a node of a class, beside why neither can be made
+## ("" when one can), as [PackedScene, String].
+static func what_to_add(node_type: String, instance_path: String, scene_path: String) -> Array:
+	if node_type.is_empty() == instance_path.is_empty():
+		return [
+			null,
+			"add takes nodeType for a node of a class, or instancePath for a scene, and one of them only."
+		]
+	if not instance_path.is_empty():
+		var cycle: String = _instancing_cycle(scene_path, instance_path)
+		if not cycle.is_empty():
+			return [null, cycle]
+		if not ResourceLoader.exists(instance_path, "PackedScene"):
+			return [null, "No scene at %s to instance." % instance_path]
+		var packed: PackedScene = ResourceLoader.load(instance_path, "PackedScene") as PackedScene
+		if packed == null or not packed.can_instantiate():
+			return [null, "%s does not load as a scene that can be instanced." % instance_path]
+		return [packed, ""]
+	if node_type.begins_with("res://") or node_type.get_extension() in ["tscn", "scn"]:
+		return [
+			null,
+			(
+				"nodeType must be a node class, and %s is a scene: pass it as instancePath to instance it."
+				% node_type
+			)
+		]
+	if not ClassDB.class_exists(node_type) or not ClassDB.is_parent_class(node_type, "Node"):
+		return [null, "nodeType must be a node class, and %s is not one." % node_type]
+	if not ClassDB.can_instantiate(node_type):
+		return [null, "%s cannot be instantiated." % node_type]
+	return [null, ""]
+
+
+## A new node of [param node_type], or an instance of [param packed] when there is one. The instance
+## is made in the editor's edit state, so the pack writes it as an instance of its file, and owning
+## its root leaves its own nodes to the instanced scene.
+static func made(packed: PackedScene, node_type: String) -> Node:
+	if packed != null:
+		return packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
+	var node: Object = ClassDB.instantiate(node_type)
+	return node as Node
+
+
+## A copy of [param source] and the nodes under it that [param root] owns, each copy recorded in
+## [param copies] against its source, or null when an instance in it no longer loads.
+static func copied(source: Node, root: Node, copies: Dictionary) -> Node:
+	var copy: Node = null
+	if not source.scene_file_path.is_empty():
+		# An instanced scene made again from its file, so the copy is an instance too. Node.duplicate
+		# makes a plain node of the instance's class, and the pack saved it with every property of the
+		# instance's root frozen into this scene.
+		var packed: PackedScene = ResourceLoader.load(source.scene_file_path, "PackedScene") as PackedScene
+		if packed == null:
+			return null
+		copy = packed.instantiate(PackedScene.GEN_EDIT_STATE_INSTANCE)
+		for declared: Dictionary in source.get_property_list():
+			if not (Read.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE):
+				continue
+			var property: String = str(declared.get("name", ""))
+			var value: Variant = source.get(property)
+			if not PropertyValues.same(copy.get(property), value):
+				copy.set(property, value)
+		for group: StringName in source.get_groups():
+			if not copy.is_in_group(group):
+				copy.add_to_group(group, true)
+	else:
+		copy = source.duplicate(Node.DUPLICATE_GROUPS | Node.DUPLICATE_SCRIPTS)
+		for child: Node in copy.get_children():
+			copy.remove_child(child)
+			child.free()
+	copy.name = source.name
+	copies[source] = copy
+	# Only what this scene owns: an instance's own nodes come with the instance.
+	for child: Node in source.get_children():
+		if child.owner == root:
+			var under: Node = copied(child, root, copies)
+			if under == null:
+				return null
+			copy.add_child(under)
+	return copy
+
+
+## Gives each copy in [param copies] the persistent connections its source has, to the copy of the
+## target when the target was copied too. A connection an instance makes inside itself is skipped:
+## the instance made again from its file already has it.
+static func reconnect(copies: Dictionary, top: Node) -> void:
+	for key: Variant in copies:
+		var source: Node = key
+		var copy: Node = copies[key]
+		for info: Dictionary in source.get_signal_list():
+			var signal_name: String = str(info.get("name", ""))
+			for conn: Dictionary in source.get_signal_connection_list(signal_name):
+				var flags: int = Read.as_int(conn.get("flags", 0))
+				var callable: Callable = conn.get("callable", Callable())
+				var target: Object = callable.get_object()
+				if not flags & Object.CONNECT_PERSIST or target == null:
+					continue
+				var to: Object = copies.get(target, target)
+				if to == target and target is Node and (target == top or top.is_ancestor_of(target as Node)):
+					continue
+				var aimed: Callable = Callable(to, callable.get_method())
+				if (
+					not copy.is_connected(signal_name, aimed)
+					and copy.connect(signal_name, aimed, flags) != OK
+				):
+					push_error(
+						"gdharness: could not copy the connection %s of %s" % [signal_name, source.name]
+					)
+
+
+## Owns [param node] and the nodes under it to [param root], except those an instanced scene
+## inside it owns: giving those to the root made the pack write the instance's own nodes into this
+## scene as overrides.
+static func own(node: Node, root: Node) -> void:
+	node.owner = root
+	for child: Node in node.get_children():
+		if child.owner == null or child.owner == root:
+			own(child, root)
+
+
+## Why [param asked] is not a position [param node] can take among [param parent]'s children, or ""
+## when it is, or when none was asked for. [param node] is null for a node not yet added.
+static func unplaceable(parent: Node, node: Node, asked: Variant) -> String:
+	if asked == null:
+		return ""
+	var others: int = parent.get_child_count() - (1 if node != null and node.get_parent() == parent else 0)
+	var at: int = Read.as_int(asked, -1)
+	if at < 0 or at > others:
+		return (
+			"index %s is not a place among the %d other children of %s: give 0 to %d, 0 for first."
+			% [
+				str(at) if asked is int or asked is float else JSON.stringify(asked),
+				others,
+				parent.name,
+				others
+			]
+		)
+	return ""
+
+
+## Moves [param node] to [param asked] among its siblings, when a place was asked for.
+static func place(node: Node, asked: Variant) -> void:
+	if asked != null:
+		node.get_parent().move_child(node, Read.as_int(asked))
+
+
+## Why [param instanced] cannot be instanced into [param scene_path], or "" when it can: a scene
+## inside itself, directly or through the scenes it instances, which Godot's own dialog refuses and
+## which never finishes loading.
+static func _instancing_cycle(scene_path: String, instanced: String) -> String:
+	var seen: Dictionary[String, bool] = {}
+	var waiting: Array[String] = [instanced]
+	while not waiting.is_empty():
+		var at: String = waiting.pop_back()
+		if at == scene_path:
+			return (
+				"%s cannot be instanced into %s: it %s, so the scene would hold itself."
+				% [instanced, scene_path, "is that scene" if at == instanced else "instances it"]
+			)
+		if seen.has(at):
+			continue
+		seen[at] = true
+		for dependency: String in ResourceLoader.get_dependencies(at):
+			# Slices joined by "::", the UID, the type and the path, some of them empty.
+			for part: String in dependency.split("::"):
+				if part.begins_with("res://") and part.get_extension() in ["tscn", "scn"]:
+					waiting.append(part)
+	return ""

package/build/godot/addons/gdharness_editor/tools/scene_placing.gd.uid

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