gdharness 1.3.0 → 1.3.2

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

@@ -4,12 +4,12 @@ extends RefCounted
 ## question, where one is on screen, a property's value, the metrics. What it changes, a property
 ## written or a method called, is in runtime_changes.gd.
 
-const Paths = preload("runtime_paths.gd")
-const Read = preload("reading.gd")
-const Says = preload("runtime_says.gd")
-const Screen = preload("runtime_screen.gd")
-const Values = preload("runtime_values.gd")
-const Words = preload("runtime_words.gd")
+const GdhPaths = preload("runtime_paths.gd")
+const GdhRead = preload("reading.gd")
+const GdhSays = preload("runtime_says.gd")
+const GdhScreen = preload("runtime_screen.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhWords = preload("runtime_words.gd")
 
 ## The most nodes one find answers with, unless asked for fewer: enough for any real query and
 ## far short of the tree dump a query exists to avoid.
@@ -32,7 +32,7 @@ const LIMIT_CEILING: int = 5000
 const FRAMES_TIMED: int = 120
 
 var _host: Node
-var _values: Values
+var _values: GdhValues
 ## How long each of the last frames took, oldest first, in microseconds, as the game timed them.
 var _frame_usec: PackedInt64Array = PackedInt64Array()
 ## How many physics steps ran in each of those frames, in the same order.
@@ -43,7 +43,7 @@ var _last_physics_frames: int = 0
 
 ## The host is the autoload, which is how the tree is reached: it is not in one when the
 ## modules are built, and a fixture may put it in one later.
-func _init(host: Node, values: Values) -> void:
+func _init(host: Node, values: GdhValues) -> void:
 	_host = host
 	_values = values
 
@@ -56,8 +56,8 @@ func _init(host: Node, values: Values) -> void:
 ## characters, and the same question as a find with one property answered two.
 func get_tree(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
-	var max_depth: int = Read.as_int(params.get("depth", 3), 3)
-	var include_properties: bool = Read.as_bool(params.get("include_properties", false))
+	var max_depth: int = GdhRead.as_int(params.get("depth", 3), 3)
+	var include_properties: bool = GdhRead.as_bool(params.get("include_properties", false))
 	var named: Array[String] = []
 	var listed: Variant = params.get("properties", [])
 	if listed is Array:
@@ -66,7 +66,7 @@ func get_tree(params: Dictionary) -> Dictionary:
 	else:
 		return {"type": "error", "message": "properties must be a list of property names"}
 
-	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	var reached: Dictionary = GdhValues.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
 		return reached
 	var root: Node = reached["node"]
@@ -101,8 +101,8 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	for filter: String in FILTERS:
 		wanted[filter] = str(params.get(filter, ""))
 	var wanted_property: String = str(params.get("property", ""))
-	var include_hidden: bool = Read.as_bool(params.get("include_hidden", true), true)
-	var limit: int = Read.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT)
+	var include_hidden: bool = GdhRead.as_bool(params.get("include_hidden", true), true)
+	var limit: int = GdhRead.as_int(params.get("limit", FIND_LIMIT), FIND_LIMIT)
 	if limit < 1 or limit > LIMIT_CEILING:
 		return {
 			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
@@ -114,12 +114,12 @@ func find_nodes(params: Dictionary) -> Dictionary:
 		wanted["script"] = "res://" + wanted["script"]
 
 	# Split once here rather than for each node the walk passes.
-	var names: Array[String] = Says.split_at_bars(wanted["name"])
+	var names: Array[String] = GdhSays.split_at_bars(wanted["name"])
 	if not wanted["name"].is_empty() and names.is_empty():
 		var bars_only: String = 'name "%s" is only bars, so it names no node; write the names between them'
 		return {"type": "error", "message": bars_only % wanted["name"]}
 
-	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	var reached: Dictionary = GdhValues.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
 		return reached
 	var root: Node = reached["node"]
@@ -131,14 +131,14 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	# find would have matched if the name had been read the way it was probably meant.
 	var plain_names: Array[String] = []
 	for named: String in names:
-		if Says.is_plain(named):
+		if GdhSays.is_plain(named):
 			plain_names.append(named)
 	var nearly: int = 0
 	# The same for the words: a glob is matched against the whole text, and one written as a prefix
 	# by habit, "Taken together*", missed the label whose sentence those words are in the middle of.
 	# Nothing found then read as the words not being on screen, which is the wrong conclusion when
 	# checking that a change to the text landed.
-	var widened_says: String = Says.widened(wanted["says"])
+	var widened_says: String = GdhSays.widened(wanted["says"])
 	var widened: Dictionary[String, String] = {}
 	for filter: String in wanted:
 		widened[filter] = widened_says if filter == "says" else wanted[filter]
@@ -192,7 +192,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			near_words.append('"%s"' % named)
 		var opened: Array[String] = []
 		for named: String in names:
-			opened.append("*%s*" % named if Says.is_plain(named) else named)
+			opened.append("*%s*" % named if GdhSays.is_plain(named) else named)
 		(
 			notes
 			. append(
@@ -203,7 +203,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 						"" if nearly > 0 else "hidden ",
 						holding,
 						" or ".join(PackedStringArray(near_words)),
-						Says.joined_at_bars(opened),
+						GdhSays.joined_at_bars(opened),
 						"" if nearly > 0 else " with includeHidden true",
 					]
 				)
@@ -304,19 +304,19 @@ func _found(node: Node, wanted_property: String) -> Dictionary:
 	if wanted_property.is_empty():
 		return entry
 	entry["property"] = wanted_property
-	# Through a path as well, for the reason [method Paths.walk_to] gives. A step that is not there on
+	# Through a path as well, for the reason [method GdhPaths.walk_to] gives. A step that is not there on
 	# this node reads as not having the property rather than as a refusal, which is the rule this
 	# whole function is written to: a find matches nodes of several classes on purpose.
-	var reached: Dictionary = Paths.walk_to(node, str(entry["path"]), wanted_property)
+	var reached: Dictionary = GdhPaths.walk_to(node, str(entry["path"]), wanted_property)
 	if reached.has("message"):
 		entry["has_property"] = false
 		return entry
 	var holder: Variant = reached["holder"]
 	var named: String = reached["name"]
-	var has: bool = Paths.can_read(holder, named)
+	var has: bool = GdhPaths.can_read(holder, named)
 	entry["has_property"] = has
 	if has:
-		entry["value"] = _values.serialize(Paths.read_under(holder, named))
+		entry["value"] = _values.serialize(GdhPaths.read_under(holder, named))
 	return entry
 
 
@@ -356,7 +356,7 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 	# What this node says, rather than everything said underneath it. A row is then found by the
 	# label in it, and the path answered is that label's, which is where the words a caller is
 	# looking at actually are: matching every container above it would answer with the screen.
-	if not wanted["says"].is_empty() and not Says.says(node, wanted["says"]):
+	if not wanted["says"].is_empty() and not GdhSays.says(node, wanted["says"]):
 		return false
 	var script: Variant = node.get_script()
 	if not wanted["script"].is_empty():
@@ -408,14 +408,14 @@ static func _script_is(attached: Script, wanted: String) -> bool:
 ## whose interesting half is below the cut says so in a number rather than in a flag.
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
-	var include_hidden: bool = Read.as_bool(params.get("include_hidden", false))
-	var limit: int = Read.as_int(params.get("limit", READ_LIMIT), READ_LIMIT)
+	var include_hidden: bool = GdhRead.as_bool(params.get("include_hidden", false))
+	var limit: int = GdhRead.as_int(params.get("limit", READ_LIMIT), READ_LIMIT)
 	if limit < 1 or limit > LIMIT_CEILING:
 		return {
 			"type": "error", "message": "limit is from 1 to %d, and %d was asked for" % [LIMIT_CEILING, limit]
 		}
 
-	var reached: Dictionary = Values.node_at(_host.get_tree().root, root_path)
+	var reached: Dictionary = GdhValues.node_at(_host.get_tree().root, root_path)
 	if reached.has("message"):
 		return reached
 	var root: Node = reached["node"]
@@ -453,7 +453,7 @@ func read_text(params: Dictionary) -> Dictionary:
 func _read_into(node: Node, include_hidden: bool, most: int, into: Array[String]) -> int:
 	var left_out: int = 0
 	if include_hidden or shown(node):
-		for said: String in Words.lines_said_by(node):
+		for said: String in GdhWords.lines_said_by(node):
 			if into.size() < most:
 				into.append(said)
 			else:
@@ -472,7 +472,7 @@ func get_rect(params: Dictionary) -> Dictionary:
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
 
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
 	var node: Node = standing["node"]
@@ -491,7 +491,7 @@ func get_rect(params: Dictionary) -> Dictionary:
 			"canvas": _values.serialize(canvas_rect),
 			"window":
 			_values.serialize(
-				Screen.rect_in_window(
+				GdhScreen.rect_in_window(
 					control.get_viewport(),
 					control.get_global_transform_with_canvas() * Rect2(Vector2.ZERO, control.size)
 				)
@@ -500,7 +500,7 @@ func get_rect(params: Dictionary) -> Dictionary:
 	if node is Node2D:
 		var item: Node2D = node
 		var canvas_position: Vector2 = item.get_global_transform_with_canvas().origin
-		var window_position: Vector2 = Screen.in_window(item.get_viewport(), canvas_position)
+		var window_position: Vector2 = GdhScreen.in_window(item.get_viewport(), canvas_position)
 		return {
 			"type": "point",
 			"path": node_path,
@@ -544,12 +544,12 @@ func _in_the_frame(node_path: String, item: Node3D) -> Dictionary:
 	if found.has("aim"):
 		var aim: Vector2 = found["aim"]
 		answer["canvas"] = _values.serialize(aim)
-		answer["window"] = _values.serialize(Screen.in_window(drawn_in, aim))
+		answer["window"] = _values.serialize(GdhScreen.in_window(drawn_in, aim))
 	if found.has("rect"):
 		var covered: Rect2 = found["rect"]
 		answer["covers"] = {
 			"canvas": _values.serialize(covered),
-			"window": _values.serialize(Screen.rect_in_window(drawn_in, covered)),
+			"window": _values.serialize(GdhScreen.rect_in_window(drawn_in, covered)),
 		}
 	return answer
 
@@ -634,12 +634,12 @@ func get_property(params: Dictionary) -> Dictionary:
 	if node_path.is_empty() or property.is_empty():
 		return {"type": "error", "message": "Node path and property required"}
 
-	var standing: Dictionary = Values.target_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = GdhValues.target_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
 	var target: Object = standing["object"]
 
-	var reached: Dictionary = Paths.walk_to(target, node_path, property)
+	var reached: Dictionary = GdhPaths.walk_to(target, node_path, property)
 	if reached.has("message"):
 		return reached
 
@@ -647,14 +647,14 @@ func get_property(params: Dictionary) -> Dictionary:
 	var named: String = reached["name"]
 	# Asked of the holder rather than read and compared to null, because a property the holder does
 	# not have and a property that is null both read as null.
-	if not Paths.can_read(holder, named):
-		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
+	if not GdhPaths.can_read(holder, named):
+		return {"type": "error", "message": GdhPaths.nothing_there(holder, named, str(reached["called"]))}
 
 	return {
 		"type": "property",
 		"path": node_path,
 		"property": property,
-		"value": _values.serialize(Paths.read_under(holder, named)),
+		"value": _values.serialize(GdhPaths.read_under(holder, named)),
 	}
 
 
@@ -793,13 +793,13 @@ func _serialize_node_tree(
 func _named_properties_of(node: Node, path: String, named: Array[String]) -> Dictionary:
 	var properties: Dictionary = {}
 	for wanted: String in named:
-		var reached: Dictionary = Paths.walk_to(node, path, wanted)
+		var reached: Dictionary = GdhPaths.walk_to(node, path, wanted)
 		if reached.has("message"):
 			continue
 		var holder: Variant = reached["holder"]
 		var name: String = reached["name"]
-		if Paths.can_read(holder, name):
-			properties[wanted] = _values.serialize(Paths.read_under(holder, name))
+		if GdhPaths.can_read(holder, name):
+			properties[wanted] = _values.serialize(GdhPaths.read_under(holder, name))
 	return properties
 
 

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

@@ -3,7 +3,7 @@ extends RefCounted
 ## Whether a node says what a caller asked for in `says`: the one set of rules a find, a click and a
 ## wait all match words by, so the three never disagree about which control a word names.
 
-const Words = preload("runtime_words.gd")
+const GdhWords = preload("runtime_words.gd")
 
 ## Stands in for a bar written as `\|` while `says` is split into its alternatives: a character from
 ## the private use area, which no game's text uses.
@@ -25,7 +25,7 @@ static var _spaces: RegEx = null
 
 ## Whether [param node]'s own words are what [param wanted] asks for.
 static func says(node: Node, wanted: String) -> bool:
-	return matches(Words.said_by(node), wanted)
+	return matches(GdhWords.said_by(node), wanted)
 
 
 ## Whether [param said] is what [param wanted] asks for.
@@ -57,7 +57,7 @@ static func matches(said: String, wanted: String) -> bool:
 
 
 ## Each alternative of [param wanted] as a glob, open at both ends for words written plain, with
-## every space as `?`. Words that match once spaced match this as written, since spacing changes
+## every space as `?`. GdhWords that match once spaced match this as written, since spacing changes
 ## only the characters a `?` stands for, so a text that does not is answered without being spaced.
 ## Kept by what was written, as [method alternatives] keeps its split.
 static func _loose(wanted: String) -> Array[String]:

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

@@ -2,13 +2,13 @@ extends RefCounted
 
 ## Which control a click means when it names the control by the words on it rather than by path.
 
-const Items = preload("runtime_items.gd")
-const Queries = preload("runtime_queries.gd")
-const Read = preload("reading.gd")
-const Says = preload("runtime_says.gd")
-const Screen = preload("runtime_screen.gd")
-const Values = preload("runtime_values.gd")
-const Words = preload("runtime_words.gd")
+const GdhItems = preload("runtime_items.gd")
+const GdhQueries = preload("runtime_queries.gd")
+const GdhRead = preload("reading.gd")
+const GdhSays = preload("runtime_says.gd")
+const GdhScreen = preload("runtime_screen.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhWords = preload("runtime_words.gd")
 
 ## How many of the controls saying the same words a refusal names, with the index for each.
 const LISTED_CANDIDATES: int = 10
@@ -26,7 +26,7 @@ const WHOLE: int = 1
 ## The control a click by [param wanted] words presses, found under [param root_path] in the tree
 ## [param root] heads, or the refusal saying why there is none or which of several:
 ## {"path", "found"} or {"type", "message"}, with `item` as well when the match is an item of a
-## control drawing a list, which [method Items.item_rect] places.
+## control drawing a list, which [method GdhItems.item_rect] places.
 ##
 ## Matched the way a find matches `says`, against a control's own words, and only among controls
 ## the player can see. A match inside a button presses the button, because the label is what says
@@ -45,7 +45,7 @@ const WHOLE: int = 1
 ## on screen for a player, and a click at it lands on the thing on top. The screen a game shows
 ## over its hall covers the hall's drawers without hiding them, so their words matched as well.
 static func control_saying(root: Node, root_path: String, wanted: String, which: Variant) -> Dictionary:
-	var reached: Dictionary = Values.node_at(root, root_path)
+	var reached: Dictionary = GdhValues.node_at(root, root_path)
 	if reached.has("message"):
 		return reached
 	var matched: Array[Control] = []
@@ -66,22 +66,22 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var pending: Array[Node] = [reached["node"]]
 	while not pending.is_empty():
 		var node: Node = pending.pop_front()
-		if node is Control and Says.says(node, wanted):
-			if not Queries.shown(node):
+		if node is Control and GdhSays.says(node, wanted):
+			if not GdhQueries.shown(node):
 				hidden += 1
-				if _says_exactly(Words.said_by(node), wanted):
+				if _says_exactly(GdhWords.said_by(node), wanted):
 					exact_out_of_reach.append(node)
 					out_of_reach_as.append("hidden")
-			elif Words.draws_a_list(node):
+			elif GdhWords.draws_a_list(node):
 				# Each item a match of its own, so the words of one tab are matched as a whole and the
 				# index picks between two items saying them as it does between two buttons.
 				var drawing: Control = node
-				for entry: Dictionary in Words.items_of(drawing):
+				for entry: Dictionary in GdhWords.items_of(drawing):
 					var words: String = entry["says"]
-					if not Says.matches(words, wanted):
+					if not GdhSays.matches(words, wanted):
 						continue
 					var whole: bool = _says_exactly(words, wanted)
-					var drawn_at_now: Rect2 = Items.item_rect(drawing, entry["item"], wanted)
+					var drawn_at_now: Rect2 = GdhItems.item_rect(drawing, entry["item"], wanted)
 					matched.append(drawing)
 					said.append(words)
 					exact.append(whole)
@@ -95,7 +95,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			else:
 				var control: Control = node
 				var target: Control = _pressed_through(control)
-				var words: String = Words.said_by(node)
+				var words: String = GdhWords.said_by(node)
 				var whole: bool = _says_exactly(words, wanted)
 				var buried: bool = not whole and _inside_a_word(words, wanted)
 				var at: int = matched.find(target)
@@ -193,7 +193,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				% [_described(best, ranks[0], wanted, under), order, _candidates(targets, lines)]
 			)
 		}
-	var index: int = 0 if which == null else Read.as_int(which, -1)
+	var index: int = 0 if which == null else GdhRead.as_int(which, -1)
 	if index < 0 or index >= targets.size():
 		# A number arrives from JSON as a float, and 5 was quoted back as 5.0.
 		var given: String = str(index) if index >= 0 else str(which)
@@ -295,7 +295,7 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var answer: Dictionary = {"path": str(targets[index].get_path()), "found": found}
 	if picked_items[index] != null:
 		answer["item"] = picked_items[index]
-		found["item"] = Items.item_named(targets[index], picked_items[index], lines[index])
+		found["item"] = GdhItems.item_named(targets[index], picked_items[index], lines[index])
 	return answer
 
 
@@ -345,9 +345,9 @@ static func pointer_turned_off_by(control: Control) -> Control:
 ## named WARD, and read as its words run together it said WARD only as part of more, level with
 ## "WARDSPITE" over its own description, and a click on WARD was refused as not clear.
 static func _says_exactly(written: String, wanted: String) -> bool:
-	var said: String = Says.spaced(written)
-	for words: String in Says.alternatives(wanted):
-		if not Says.is_plain(words):
+	var said: String = GdhSays.spaced(written)
+	for words: String in GdhSays.alternatives(wanted):
+		if not GdhSays.is_plain(words):
 			if said.matchn(words):
 				return true
 			continue
@@ -364,11 +364,11 @@ static func _says_exactly(written: String, wanted: String) -> bool:
 ## never starting where a word starts: "out" in "Scout". Words starting a longer one count as said,
 ## "Recruit" in "Recruits", and so does anything matched by a pattern.
 static func _inside_a_word(written: String, wanted: String) -> bool:
-	var said: String = Says.spaced(written).to_lower()
+	var said: String = GdhSays.spaced(written).to_lower()
 	var found: bool = false
-	for words: String in Says.alternatives(wanted):
+	for words: String in GdhSays.alternatives(wanted):
 		var looked_for: String = words.to_lower()
-		if not Says.is_plain(words) or not _in_a_word(looked_for.unicode_at(0)):
+		if not GdhSays.is_plain(words) or not _in_a_word(looked_for.unicode_at(0)):
 			return false
 		var at: int = said.find(looked_for)
 		while at >= 0:
@@ -391,8 +391,8 @@ static func _described(count: int, rank: int, wanted: String, under: String) ->
 	var what: String = "button" if rank & ENABLED_BUTTON else "control"
 	var how: String = '"%s"' % wanted
 	var plain: bool = true
-	for words: String in Says.alternatives(wanted):
-		plain = plain and Says.is_plain(words)
+	for words: String in GdhSays.alternatives(wanted):
+		plain = plain and GdhSays.is_plain(words)
 	if plain:
 		how = ('exactly "%s"' if rank & WHOLE else '"%s" as part of more') % wanted
 	if count == 1:
@@ -756,7 +756,7 @@ static func _window_over(target: Control, point: Vector2, window: Window) -> boo
 	if window.get_parent() == null or window.is_ancestor_of(target):
 		return false
 	var host: Viewport = window.get_parent().get_viewport()
-	for step: Dictionary in Screen.steps_out(target.get_viewport(), point):
+	for step: Dictionary in GdhScreen.steps_out(target.get_viewport(), point):
 		if step["viewport"] != host:
 			continue
 		var there: Vector2 = step["point"]
@@ -820,7 +820,7 @@ static func _off_screen(target: Control, aim: Vector2) -> bool:
 	var point: Vector2 = target.get_global_transform_with_canvas() * aim + _moved_by(target, moves)
 	if _clipped_away(target, point, moves) or not target.get_viewport().get_visible_rect().has_point(point):
 		return true
-	var reached: Dictionary = Screen.reach(target.get_viewport(), point)
+	var reached: Dictionary = GdhScreen.reach(target.get_viewport(), point)
 	var viewport: Viewport = reached["viewport"]
 	var there: Vector2 = reached["point"]
 	return not viewport.get_visible_rect().has_point(there)
@@ -855,11 +855,11 @@ static func _clipped_away(
 ## words. A line in another font or holding an image measures off from what is drawn, which a wide
 ## line with nothing between the words and its start hardly does.
 static func point_on_words(label: RichTextLabel, wanted: String) -> Dictionary:
-	var text: String = Says.spaced(Words.said_by(label))
+	var text: String = GdhSays.spaced(GdhWords.said_by(label))
 	var start: int = -1
 	var length: int = 0
-	for words: String in Says.alternatives(wanted):
-		if not Says.is_plain(words):
+	for words: String in GdhSays.alternatives(wanted):
+		if not GdhSays.is_plain(words):
 			continue
 		var at: int = text.findn(words)
 		if at >= 0 and (start < 0 or at < start):
@@ -927,7 +927,7 @@ static func _open_menu_note(root: Node, wanted: String) -> String:
 		if menu != null and menu.visible:
 			for item: int in menu.item_count:
 				var text: String = menu.get_item_text(item)
-				if Says.matches(text, wanted):
+				if GdhSays.matches(text, wanted):
 					var owner: Node = menu.get_parent()
 					var named: Node = owner if owner is MenuButton or owner is OptionButton else menu
 					return (

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

@@ -3,11 +3,11 @@ extends RefCounted
 ## What reaches the running game the way a keyboard reaches it: text typed into the field that has
 ## the focus, and an item chosen out of a menu the way a keyboard chooses one.
 
-const Menus = preload("runtime_menus.gd")
-const Read = preload("reading.gd")
-const Targets = preload("runtime_targets.gd")
-const Values = preload("runtime_values.gd")
-const Words = preload("runtime_words.gd")
+const GdhMenus = preload("runtime_menus.gd")
+const GdhRead = preload("reading.gd")
+const GdhTargets = preload("runtime_targets.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhWords = preload("runtime_words.gd")
 
 ## The two characters a field reads as keys rather than as text.
 const NEWLINE: int = 10
@@ -41,7 +41,7 @@ func _init(host: Node) -> void:
 ## back now rather than echoed from the request, so a call that typed somewhere unhelpful says so.
 func inject_text(params: Dictionary) -> Dictionary:
 	var text: String = str(params.get("text", ""))
-	var over: bool = Read.as_bool(params.get("replace", false))
+	var over: bool = GdhRead.as_bool(params.get("replace", false))
 	if text.is_empty() and not over:
 		return {"type": "error", "message": "text needs something to type, or replace to empty a field"}
 
@@ -127,7 +127,7 @@ static func _select_everything(focused: Control) -> bool:
 static func _what_it_holds(focused: Control) -> Variant:
 	var field: LineEdit = focused as LineEdit
 	if field != null:
-		return Words.masked(field) if field.secret else field.text
+		return GdhWords.masked(field) if field.secret else field.text
 	var box: TextEdit = focused as TextEdit
 	if box == null:
 		return null
@@ -219,12 +219,12 @@ func choose(params: Dictionary) -> Dictionary:
 	var node_path: String = str(params.get("path", ""))
 	if node_path.is_empty():
 		return {"type": "error", "message": "Node path required"}
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
+	var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
 	if standing.has("message"):
 		return standing
 	var node: Node = standing["node"]
 
-	var menu: PopupMenu = Menus.menu_of(node)
+	var menu: PopupMenu = GdhMenus.menu_of(node)
 	if menu == null:
 		return {
 			"type": "error",
@@ -241,7 +241,7 @@ func choose(params: Dictionary) -> Dictionary:
 			"message":
 			(
 				"%s needs the item named, by text or index. It holds: %s"
-				% [node_path, ", ".join(Menus.items_of(menu))]
+				% [node_path, ", ".join(GdhMenus.items_of(menu))]
 			)
 		}
 
@@ -255,7 +255,7 @@ func choose(params: Dictionary) -> Dictionary:
 		return {
 			"type": "error",
 			"message":
-			"%s is not visible%s, so its menu cannot be opened" % [node_path, Targets.why_hidden(holder)]
+			"%s is not visible%s, so its menu cannot be opened" % [node_path, GdhTargets.why_hidden(holder)]
 		}
 
 	# Shown first, because a menu nobody has opened has no focus to move and the press would go to
@@ -263,15 +263,15 @@ func choose(params: Dictionary) -> Dictionary:
 	# a menu: one rebuilt on about_to_popup was read as it stood before, measured on 4.7.2, and the
 	# index found in the old items chose another item of the new ones. An OptionButton opens its own;
 	# a bare PopupMenu is popped where it already sits, which leaves a menu already open where it is.
-	var opened: bool = Menus.open_the_menu(node, menu)
+	var opened: bool = GdhMenus.open_the_menu(node, menu)
 	await _host.get_tree().process_frame
 
-	var found: Array[int] = Menus.wanted_items(menu, params)
+	var found: Array[int] = GdhMenus.wanted_items(menu, params)
 	if found.size() > 1:
 		await _shut(menu, opened)
 		var tied: Array[String] = []
 		for at: int in found:
-			tied.append("%d: %s" % [at, Words.item_says(menu, at)])
+			tied.append("%d: %s" % [at, GdhWords.item_says(menu, at)])
 		return {
 			"type": "error",
 			"message":
@@ -294,7 +294,7 @@ func choose(params: Dictionary) -> Dictionary:
 		"type": "chosen",
 		"path": node_path,
 		"index": index,
-		"text": Words.item_says(menu, index),
+		"text": GdhWords.item_says(menu, index),
 		"id": menu.get_item_id(index),
 		"opened": opened,
 		"menu": str(menu.get_path()),
@@ -329,13 +329,13 @@ func choose(params: Dictionary) -> Dictionary:
 			)
 		}
 
-	answer["control_afterwards"] = Values.afterwards(node)
+	answer["control_afterwards"] = GdhValues.afterwards(node)
 	# What the button in front of the menu reads now: a menu item that fired changes the thing
 	# holding it. A button the pick took away has nothing to read, and that it went is the answer.
 	if answer["control_afterwards"] == "in_tree" and node is OptionButton:
 		var chooser: OptionButton = node
 		answer["selected"] = chooser.get_selected()
-		answer["shows"] = Words.said_by(chooser)
+		answer["shows"] = GdhWords.said_by(chooser)
 	return answer
 
 
@@ -352,9 +352,9 @@ func _shut(menu: PopupMenu, opened: bool) -> void:
 ## Why item [param index] of [param menu] is not something to choose, or "" when it is.
 static func _not_a_choice(node_path: String, menu: PopupMenu, index: int) -> String:
 	if index < 0:
-		return "%s has no such item. It holds: %s" % [node_path, ", ".join(Menus.items_of(menu))]
+		return "%s has no such item. It holds: %s" % [node_path, ", ".join(GdhMenus.items_of(menu))]
 	if menu.is_item_separator(index):
-		var heading: String = Words.item_says(menu, index).strip_edges()
+		var heading: String = GdhWords.item_says(menu, index).strip_edges()
 		if heading.is_empty():
 			return "%s item %d is a separator, not a choice" % [node_path, index]
 		return (
@@ -362,7 +362,7 @@ static func _not_a_choice(node_path: String, menu: PopupMenu, index: int) -> Str
 			% [node_path, index, heading]
 		)
 	if menu.is_item_disabled(index):
-		return "%s item %d, %s, is disabled" % [node_path, index, Words.item_says(menu, index)]
+		return "%s item %d, %s, is disabled" % [node_path, index, GdhWords.item_says(menu, index)]
 	return ""