gdharness 1.3.8 → 1.3.10

package/build/godot/operations/input_actions.gd

@@ -3,6 +3,15 @@ extends RefCounted
 const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhProjectFile = preload("project_file.gd")
+## The device an event matches every device with, InputMap's ALL_DEVICES, which GDScript is not given.
+const ALL_DEVICES: int = -1
+const MOUSE_NAMES: String = (
+	"1 left, 2 right, 3 middle, 4 and 5 the wheel up and down, 6 and 7 the wheel left and right,"
+	+ " 8 and 9 the side buttons"
+)
+const AXIS_NAMES: String = (
+	"0 and 1 the left stick across and down, 2 and 3 the right stick," + " 4 and 5 the triggers"
+)
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -108,7 +117,13 @@ func _init(p_log: GdhLog) -> void:
 func add_input_action(params: Dictionary) -> Dictionary:
 	var action_name: String = str(params.get("action_name", ""))
 	var events: Array = params.get("events", [])
-	var deadzone: float = GdhRead.as_float(params.get("deadzone", 0.5), 0.5)
+	var setting: String = "input/" + action_name
+	var held: Variant = ProjectSettings.get_setting(setting) if ProjectSettings.has_setting(setting) else null
+	var old: Dictionary = held if held is Dictionary else {}
+	var old_deadzone: float = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+	# A rebind that names no deadzone keeps the one the action has, which a caller adding a key did
+	# not mean to change.
+	var deadzone: float = GdhRead.as_float(params.get("deadzone", old_deadzone), old_deadzone)
 
 	_log.info("Adding input action: " + action_name)
 	# The editor's Input Map refuses these, since project.godot keys an action by its name and
@@ -139,47 +154,11 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		if not event is Dictionary:
 			return _log.failure("Every event must be an object, not " + JSON.stringify(event))
 		var fields: Dictionary = event
-		var event_type: String = str(fields.get("type", ""))
-
-		match event_type:
-			"key":
-				var keycode: String = str(fields.get("keycode", ""))
-				if keycode.is_empty():
-					return _log.failure("A key event needs keycode")
-				var key_value: int = _keycode_value(keycode)
-				if key_value == KEY_NONE:
-					return _log.failure(_unknown_key(keycode))
-
-				var event_config: Dictionary = {"class_name": "InputEventKey", "keycode": key_value}
-				if fields.get("ctrl", false):
-					event_config["ctrl_pressed"] = true
-				if fields.get("alt", false):
-					event_config["alt_pressed"] = true
-				if fields.get("shift", false):
-					event_config["shift_pressed"] = true
-				events_config.append(event_config)
-
-			"mouse_button":
-				events_config.append(
-					{"class_name": "InputEventMouseButton", "button_index": fields.get("button", 1)}
-				)
-
-			"joypad_button":
-				events_config.append(
-					{"class_name": "InputEventJoypadButton", "button_index": fields.get("button", 0)}
-				)
-
-			"joypad_axis":
-				var motion: Dictionary = {
-					"class_name": "InputEventJoypadMotion",
-					"axis": fields.get("axis", 0),
-					"axis_value": fields.get("axisValue", 1),
-				}
-				events_config.append(motion)
-
-			_:
-				var known: String = "key, mouse_button, joypad_button, joypad_axis"
-				return _log.failure("Unknown event type: " + event_type + ". One of " + known + ".")
+		var built: Variant = _event_config(fields)
+		if built is String:
+			return _log.failure(str(built))
+		var event_config: Dictionary = built
+		events_config.append(event_config)
 
 	if events_config.is_empty():
 		return _log.failure("events must hold at least one event")
@@ -190,7 +169,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 
 	# 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(),
@@ -199,8 +177,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		"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:
@@ -210,7 +186,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 					var bound: InputEvent = event
 					old_events.append(_shaped(bound))
 		answer["old_events"] = old_events
-		answer["old_deadzone"] = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+		answer["old_deadzone"] = old_deadzone
 
 	# 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.
@@ -226,9 +202,12 @@ func add_input_action(params: Dictionary) -> Dictionary:
 ## 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.device != ALL_DEVICES:
+		shaped["device"] = event.device
 	if event is InputEventKey:
 		var key: InputEventKey = event
-		shaped["keycode"] = key.keycode
+		if key.keycode != KEY_NONE or key.physical_keycode == KEY_NONE:
+			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"]:
@@ -293,14 +272,28 @@ func remove_input_action(params: Dictionary) -> Dictionary:
 		return _log.failure("This project has no input action named " + action_name)
 	# The engine registers its own ui_ actions with a default, so clearing one from project.godot
 	# puts the engine's binding back rather than removing the action.
-	if ProjectSettings.property_get_revert(setting) != null:
+	var engine_binding: Variant = ProjectSettings.property_get_revert(setting)
+	if engine_binding != null:
+		# At the engine's binding the file holds no line for it, and the refusal for a rebound one
+		# spoke of a binding the project had never changed.
+		if ProjectSettings.get_setting(setting) == engine_binding:
+			return _log.failure(
+				(
+					(
+						"%s is one of the engine's own actions, and project.godot does not rebind it, so "
+						+ "there is nothing to remove: the engine's binding holds. Rebind it with "
+						+ "add_input_action."
+					)
+					% action_name
+				)
+			)
 		return _log.failure(
 			(
 				(
-					"%s is one of the engine's own actions: removing it from project.godot restores the "
-					+ "engine's binding rather than removing it. Rebind it with add_input_action instead."
+					"%s is one of the engine's own actions, so it cannot be removed. project_settings "
+					+ "unset %s puts the engine's binding back, and add_input_action rebinds it."
 				)
-				% action_name
+				% [action_name, setting]
 			)
 		)
 	ProjectSettings.set_setting(setting, null)
@@ -328,6 +321,7 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 			"InputEventKey":
 				var key: InputEventKey = InputEventKey.new()
 				key.keycode = GdhRead.as_int(event.get("keycode", 0)) as Key
+				key.physical_keycode = GdhRead.as_int(event.get("physical_keycode", 0)) as Key
 				key.ctrl_pressed = GdhRead.as_bool(event.get("ctrl_pressed", false))
 				key.alt_pressed = GdhRead.as_bool(event.get("alt_pressed", false))
 				key.shift_pressed = GdhRead.as_bool(event.get("shift_pressed", false))
@@ -354,6 +348,10 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 
 			_:
 				return _log.failure("Unknown input event class: " + evt_class)
+		# Every device, as the editor's Input Map binds an event: a new event names one device, and
+		# an action bound to it ignored a second joypad.
+		var bound: InputEvent = built.back()
+		bound.device = ALL_DEVICES
 
 	return {"deadzone": deadzone, "events": built}
 
@@ -361,6 +359,84 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 # The keycode for a key name as the tool spells it, or KEY_NONE for a name the table lacks.
 ## The refusal for [param key_name], which names no key: the names nearest it, then every name taken,
 ## since a name the caller has to guess at is the same guess again.
+## The event [param fields] describe, as [method build_input_action] takes it, or why it is no event.
+func _event_config(fields: Dictionary) -> Variant:
+	var event_type: String = str(fields.get("type", ""))
+	match event_type:
+		"key":
+			var keycode: String = str(fields.get("keycode", ""))
+			if keycode.is_empty():
+				return "A key event needs keycode"
+			var key_value: int = _keycode_value(keycode)
+			if key_value == KEY_NONE:
+				return _unknown_key(keycode)
+			var event_config: Dictionary = {"class_name": "InputEventKey"}
+			var physical: bool = GdhRead.as_bool(fields.get("physical", false))
+			event_config["physical_keycode" if physical else "keycode"] = key_value
+			for modifier: String in ["ctrl", "alt", "shift"]:
+				if GdhRead.as_bool(fields.get(modifier, false)):
+					event_config[modifier + "_pressed"] = true
+			return event_config
+		"mouse_button":
+			var mouse: Variant = _whole_in(
+				fields, "button", MOUSE_BUTTON_LEFT, MOUSE_BUTTON_XBUTTON2, MOUSE_NAMES
+			)
+			if mouse is String:
+				return "A mouse_button event " + str(mouse)
+			return {"class_name": "InputEventMouseButton", "button_index": mouse}
+		"joypad_button":
+			var pad: Variant = _whole_in(fields, "button", 0, JOY_BUTTON_MAX - 1, "0 is A, 1 B, 2 X, 3 Y")
+			if pad is String:
+				return "A joypad_button event " + str(pad)
+			return {"class_name": "InputEventJoypadButton", "button_index": pad}
+		"joypad_axis":
+			var axis: Variant = _whole_in(fields, "axis", 0, JOY_AXIS_MAX - 1, AXIS_NAMES)
+			if axis is String:
+				return "A joypad_axis event " + str(axis)
+			# The direction is half the binding: left on a stick and right on it are two actions, and the
+			# editor binds only a whole push one way, so a guessed direction or part of one is a binding
+			# nobody asked for.
+			var direction: Variant = fields.get("axisValue")
+			var numeric: bool = direction is int or direction is float
+			if not numeric or absf(GdhRead.as_float(direction)) != 1.0:
+				return (
+					"A joypad_axis event needs axisValue, -1 or 1, the way the axis is pushed: %s was given."
+					% _shown(direction)
+				)
+			return {
+				"class_name": "InputEventJoypadMotion",
+				"axis": axis,
+				"axis_value": GdhRead.as_float(direction)
+			}
+	var known: String = "key, mouse_button, joypad_button, joypad_axis"
+	return "Unknown event type: " + event_type + ". One of " + known + "."
+
+
+## The whole number [param fields] holds under [param key], from [param least] to [param most], or
+## the rest of a refusal saying what it takes and what [param named] each number is. A field left out
+## was given a default, a left click for a mouse event and axis 0 for a stick, and written as bound.
+static func _whole_in(fields: Dictionary, key: String, least: int, most: int, named: String) -> Variant:
+	var held: Variant = fields.get(key)
+	if held is int or held is float:
+		var number: float = GdhRead.as_float(held)
+		if number == floorf(number) and number >= least and number <= most:
+			return int(number)
+	return (
+		"needs %s, a whole number from %d to %d (%s): %s was given." % [key, least, most, named, _shown(held)]
+	)
+
+
+## [param held] as the caller wrote it: JSON has one kind of number, so 10 arrives as 10.0.
+static func _shown(held: Variant) -> String:
+	if held == null:
+		return "none"
+	if held is float:
+		var number: float = held
+		if is_finite(number) and number == floorf(number):
+			return str(int(number))
+	return JSON.stringify(held)
+
+
 static func _unknown_key(key_name: String) -> String:
 	var every: PackedStringArray = []
 	var named: PackedStringArray = []

package/build/godot/operations/project_config.gd

@@ -5,6 +5,7 @@ const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhProjectFile = preload("project_file.gd")
 const GdhSerialisation = preload("serialisation.gd")
+const GdhSettingReads = preload("setting_reads.gd")
 const GdhShapes = preload("value_shapes.gd")
 
 var _log: GdhLog
@@ -19,7 +20,8 @@ func _init(p_log: GdhLog) -> void:
 func get_project_setting(params: Dictionary) -> Dictionary:
 	var prefix: String = str(params.get("prefix", ""))
 	if not prefix.is_empty():
-		return _settings_under(prefix)
+		_log.info("Listing project settings under: " + prefix)
+		return GdhSettingReads.under(prefix, _values)
 
 	var setting_path: String = str(params.get("setting", ""))
 	if setting_path.is_empty():
@@ -27,73 +29,7 @@ func get_project_setting(params: Dictionary) -> Dictionary:
 
 	_log.info("Getting project setting: " + setting_path)
 
-	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"
-
-	# 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 = {}
-	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)
-			)
-	if not overrides.is_empty():
-		result["overrides"] = overrides
-
-	return result
-
-
-# Every setting whose name starts with [prefix], with the type the engine registers for each.
-#
-# A caller after a whole family, "everything under debug/gdscript/warnings", had no way to ask: a get
-# takes one name, and the engine is the only thing that knows what the family contains. The way round
-# it was to walk ProjectSettings.get_property_list() from a script written for the purpose, which is
-# an engine start to answer a question the engine was already open for.
-#
-# 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. Reading it out of the property list is how that is caught.
-func _settings_under(prefix: String) -> Dictionary:
-	_log.info("Listing project settings under: " + prefix)
-
-	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
-		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}
+	return GdhSettingReads.one(setting_path, _values)
 
 
 # Set a project setting value
@@ -146,6 +82,14 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	if had_value and typeof(old_value) == typeof(final_value) and old_value == final_value:
 		answer["saved"] = false
 		answer["unchanged"] = true
+		if was_default:
+			answer["note"] = (
+				(
+					"%s is already this setting's default, which project.godot holds no line for:"
+					+ " the engine reads it wherever %s is asked for, so nothing was written."
+				)
+				% [JSON.stringify(_values.serialize_value(final_value)), setting_path]
+			)
 		return answer
 
 	var near: PackedStringArray = []
@@ -159,6 +103,24 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 			)
 			% [setting_path, "setting is" if near.size() == 1 else "settings are", ", ".join(near)]
 		)
+	# Written as given, since a file can be made after the setting names it, as an import makes a
+	# translation; said, since until then the engine complains of it on every boot.
+	var missing: Array[String] = _missing_files(final_value)
+	if not missing.is_empty():
+		answer["missing_files"] = missing
+		var said: String = (
+			"%s %s not exist, and the engine reports %s on every boot until %s"
+			% [
+				", ".join(missing),
+				"does" if missing.size() == 1 else "do",
+				"it" if missing.size() == 1 else "them",
+				"it does" if missing.size() == 1 else "they do",
+			]
+		)
+		var made: Array[String] = _translations_made_by(missing)
+		if not made.is_empty():
+			said += ("; project_import reimport makes the translation files from " + ", ".join(made))
+		answer["note"] = (str(answer["note"]) + " " if answer.has("note") else "") + said + "."
 	ProjectSettings.set_setting(setting_path, final_value)
 	var err: Error = GdhProjectFile.save()
 	if err != OK:
@@ -166,6 +128,89 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## The res:// files [param value] names that are not on disk: a path, an autoload's starred path, or
+## a list or dictionary of them.
+static func _missing_files(value: Variant) -> Array[String]:
+	var items: Array = []
+	if value is String or value is StringName:
+		items = [value]
+	elif value is PackedStringArray:
+		var strings: PackedStringArray = value
+		items = Array(strings)
+	elif value is Array:
+		items = value
+	elif value is Dictionary:
+		var held: Dictionary = value
+		items = held.values()
+	var missing: Array[String] = []
+	for item: Variant in items:
+		if not (item is String or item is StringName):
+			continue
+		var path: String = str(item).trim_prefix("*")
+		if not path.begins_with("res://"):
+			continue
+		if not FileAccess.file_exists(path) and not DirAccess.dir_exists_absolute(path):
+			missing.append(path)
+	return missing
+
+
+## The CSV files an import makes the translations among [param missing] from: strings.en.translation
+## from strings.csv beside it.
+static func _translations_made_by(missing: Array[String]) -> Array[String]:
+	var sources: Array[String] = []
+	for path: String in missing:
+		if path.get_extension() != "translation":
+			continue
+		var csv: String = path.get_basename().get_basename() + ".csv"
+		if FileAccess.file_exists(csv) and not csv in sources:
+			sources.append(csv)
+	return sources
+
+
+# Takes a setting's line out of project.godot, so the engine's default holds again, or nothing at all
+# for one the engine does not declare: the way back from a set, which writes a misspelt name as given.
+func unset_project_setting(params: Dictionary) -> Dictionary:
+	var setting_path: String = str(params.get("setting", ""))
+	if setting_path.is_empty():
+		return _log.failure("setting is required")
+	var default_value: Variant = ProjectSettings.property_get_revert(setting_path)
+	var held: bool = ProjectSettings.has_setting(setting_path)
+	var value: Variant = ProjectSettings.get_setting(setting_path) if held else null
+	var answer: Dictionary = {
+		"setting_path": setting_path,
+		"default_value": _values.serialize_value(default_value) if default_value != null else null,
+	}
+	# A setting at the engine's default has no line to take out, as the engine leaves it out of the file.
+	if not held or (default_value != null and value == default_value):
+		answer["removed"] = false
+		answer["saved"] = false
+		answer["note"] = "project.godot does not set %s, so there was nothing to take out." % setting_path
+		return _with_what_holds(answer, setting_path)
+	answer["old_value"] = _values.serialize_value(value)
+	# The default rather than null for a setting the engine declares: null takes the declaration away
+	# as well, and a value at its default is left out of the file all the same.
+	ProjectSettings.set_setting(setting_path, default_value)
+	var err: Error = GdhProjectFile.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+	answer["removed"] = true
+	answer["saved"] = true
+	return _with_what_holds(answer, setting_path)
+
+
+# An override has no default of its own: with it gone, a build with its feature reads the base
+# setting, and default_value, null, said nothing of that.
+func _with_what_holds(answer: Dictionary, setting_path: String) -> Dictionary:
+	var base: String = GdhSettingReads.override_base(setting_path)
+	if base.is_empty() or not ProjectSettings.has_setting(base):
+		return answer
+	answer["override_of"] = base
+	answer["holds"] = _values.serialize_value(ProjectSettings.get_setting(base))
+	var said: String = GdhSettingReads.overridden_by_none(setting_path, _values)
+	answer["note"] = said if not answer.has("note") else "%s %s" % [answer["note"], said]
+	return answer
+
+
 # The settings in the same section as [param setting_path] named nearest it, for a new one that is
 # likely a misspelt one: a setting nothing declares is written all the same, and is never read.
 static func _settings_near(setting_path: String) -> PackedStringArray:

package/build/godot/operations/project_diagnostics.gd

@@ -5,6 +5,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhLog = preload("logger.gd")
 const GdhRead = preload("reading.gd")
+const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
 
 var _log: GdhLog
@@ -129,6 +130,9 @@ func get_project_health(params: Dictionary) -> Dictionary:
 		if scene_files.size() == 0:
 			details.append("No scene files found in project")
 			deductions += 5
+		for entry: Dictionary in GdhSceneConnections.new(_log).broken():
+			details.append(GdhSceneConnections.broken_line(entry))
+			deductions += 5
 
 		checks["scenes"] = {
 			"name": "Scenes",