gdharness 1.2.42 → 1.3.1

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

@@ -4,18 +4,18 @@ extends RefCounted
 ## a whole click on a Control or a 3D node found by path. Typing and choosing from a menu, which
 ## reach the game the way a keyboard does, are in runtime_typing.gd.
 
-const Values = preload("runtime_values.gd")
+const GdhValues = preload("runtime_values.gd")
 
 ## Where a 3D node is drawn, which is what a click aimed at one has to work out first. Asked of the
 ## query module rather than worked out again here, so the place this aims at and the place a rect
 ## reports are the same place by construction rather than by agreement.
-const Queries = preload("runtime_queries.gd")
-const Read = preload("reading.gd")
-const Hover = preload("runtime_hover.gd")
-const Items = preload("runtime_items.gd")
-const Screen = preload("runtime_screen.gd")
-const Targets = preload("runtime_targets.gd")
-const Mouse = preload("runtime_mouse.gd")
+const GdhQueries = preload("runtime_queries.gd")
+const GdhRead = preload("reading.gd")
+const GdhHover = preload("runtime_hover.gd")
+const GdhItems = preload("runtime_items.gd")
+const GdhScreen = preload("runtime_screen.gd")
+const GdhTargets = preload("runtime_targets.gd")
+const GdhMouse = preload("runtime_mouse.gd")
 
 ## The distance from a capital letter to its small one in Unicode. A keycode holds the capital.
 const TO_SMALL: int = 32
@@ -40,8 +40,8 @@ static var _pointer_explained: bool = false
 static var _hover_explained: bool = false
 
 var _host: Node
-var _values: Values
-var _hover: Hover = Hover.new()
+var _values: GdhValues
+var _hover: GdhHover = GdhHover.new()
 
 ## Where the last injected pointer event put the pointer, once one has.
 ##
@@ -59,7 +59,7 @@ var _pointer_at_usec: int = 0
 var _arrival_seconds: float = 1.0 / 60.0
 
 
-func _init(host: Node, values: Values) -> void:
+func _init(host: Node, values: GdhValues) -> void:
 	_host = host
 	_values = values
 
@@ -146,16 +146,16 @@ func _arrive(position: Vector2) -> Vector2:
 ## `pressed` is how a caller says otherwise: true holds it down, false lets go of one being held.
 func inject_action(params: Dictionary) -> Dictionary:
 	var action: String = str(params.get("action", ""))
-	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
-	var strength: float = Read.as_float(params.get("strength", 1.0), 1.0)
+	var strength: float = GdhRead.as_float(params.get("strength", 1.0), 1.0)
 
 	if action.is_empty():
 		return {"type": "error", "message": "Action name required"}
 
 	if not InputMap.has_action(action):
 		return {"type": "error", "message": "Action not found: " + action}
-	var holding: Variant = Values.held_for(params)
+	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
@@ -174,7 +174,7 @@ func inject_action(params: Dictionary) -> Dictionary:
 		"action": action,
 		"pressed": held and not whole,
 		"whole": whole,
-		"held_frames": Values.held_answer(whole, frames),
+		"held_frames": GdhValues.held_answer(whole, frames),
 	}
 
 
@@ -195,7 +195,7 @@ func _say_action(action: String, down: bool, strength: float) -> void:
 ## Presses one key, and lets go of it again unless asked to hold it. See [method inject_action].
 func inject_key(params: Dictionary) -> Dictionary:
 	var keycode_raw: Variant = params.get("keycode", 0)
-	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
 	var key_label: String = str(params.get("key_label", ""))
 
@@ -203,8 +203,8 @@ func inject_key(params: Dictionary) -> Dictionary:
 		var named: String = keycode_raw
 		if not named.is_empty() and key_label.is_empty():
 			key_label = named
-	var keycode: int = 0 if keycode_raw is String else Read.as_int(keycode_raw)
-	var holding: Variant = Values.held_for(params)
+	var keycode: int = 0 if keycode_raw is String else GdhRead.as_int(keycode_raw)
+	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
@@ -229,9 +229,9 @@ func inject_key(params: Dictionary) -> Dictionary:
 	event.physical_keycode = event.keycode
 	event.key_label = event.keycode
 
-	event.shift_pressed = Read.as_bool(params.get("shift", false))
-	event.ctrl_pressed = Read.as_bool(params.get("ctrl", false))
-	event.alt_pressed = Read.as_bool(params.get("alt", false))
+	event.shift_pressed = GdhRead.as_bool(params.get("shift", false))
+	event.ctrl_pressed = GdhRead.as_bool(params.get("ctrl", false))
+	event.alt_pressed = GdhRead.as_bool(params.get("alt", false))
 
 	# The fourth thing a real event carries, and the only one a text field reads: LineEdit and
 	# TextEdit insert `unicode` and never consult the keycode, so an injected key could press any
@@ -250,7 +250,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	return {
 		"type": "input_injected",
 		"input_type": "key",
-		"held_frames": Values.held_answer(whole, frames),
+		"held_frames": GdhValues.held_answer(whole, frames),
 		"keycode": event.keycode,
 		"physical_keycode": event.physical_keycode,
 		"shift": event.shift_pressed,
@@ -284,22 +284,22 @@ func _glyph_of(keycode: Key, shifted: bool) -> int:
 ## `pressed` is how a caller asks for one half, the way a drag is made: true holds the button down,
 ## false lets go of one being held.
 func inject_mouse_click(params: Dictionary) -> Dictionary:
-	var point: Variant = Mouse.read_point(params, "x", "y", "position")
+	var point: Variant = GdhMouse.read_point(params, "x", "y")
 	if point is String:
 		return {"type": "error", "message": point}
 	var position: Vector2 = point
-	var button: int = Mouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
+	var button: int = GdhMouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
-		return Mouse.no_such_button(params.get("button"))
-	var held: bool = Read.as_bool(params.get("pressed", true), true)
-	var double: bool = Read.as_bool(params.get("doubleClick", false))
+		return GdhMouse.no_such_button(params.get("button"))
+	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
+	var double: bool = GdhRead.as_bool(params.get("doubleClick", false))
 	# A wheel step is a press and a release together, as a mouse sends one: there is no holding a
 	# wheel. A lone wheel press left the viewport's mouse focus on the control that took it, with
 	# the wheel's bit in the focus mask, and every click after it landed on that control rather
 	# than under the pointer, landing true and doing nothing, until a release was sent by hand.
-	var notch: bool = held and Mouse.mask_of(button) == 0
+	var notch: bool = held and GdhMouse.mask_of(button) == 0
 	var whole: bool = notch or not params.has("pressed")
-	var holding: Variant = Values.held_for(params)
+	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
@@ -328,7 +328,7 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 			{
 				"type": "input_injected",
 				"input_type": "mouse_click",
-				"held_frames": Values.held_answer(whole and not notch, frames),
+				"held_frames": GdhValues.held_answer(whole and not notch, frames),
 				"position": [position.x, position.y],
 				"button": button,
 				"pressed": held and not whole,
@@ -349,20 +349,15 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 ## would have carried. A relative the caller gives is kept, since a game may want to read a motion
 ## the position does not show.
 func inject_mouse_motion(params: Dictionary) -> Dictionary:
-	var point: Variant = Mouse.read_point(params, "x", "y", "position")
+	var point: Variant = GdhMouse.read_point(params, "x", "y")
 	if point is String:
 		return {"type": "error", "message": point}
 	var position: Vector2 = point
 	var relative: Vector2 = _arrive(position)
 	if params.has("relativeX") or params.has("relativeY"):
 		relative = Vector2(
-			Read.as_float(params.get("relativeX", 0.0)), Read.as_float(params.get("relativeY", 0.0))
+			GdhRead.as_float(params.get("relativeX", 0.0)), GdhRead.as_float(params.get("relativeY", 0.0))
 		)
-	elif params.has("relative"):
-		var movement: Variant = Mouse.read_point(params, "relativeX", "relativeY", "relative")
-		if movement is String:
-			return {"type": "error", "message": movement}
-		relative = movement
 
 	var supplied: bool = _follow_in_the_window(position)
 	Input.parse_input_event(_motion(position, relative))
@@ -390,26 +385,26 @@ func inject_mouse_motion(params: Dictionary) -> Dictionary:
 ## Each motion goes in a frame of its own because the engine merges the motions it is given within
 ## one frame into a single event, as it does a real mouse's, and a game counting motions counts one.
 func inject_mouse_drag(params: Dictionary) -> Dictionary:
-	var stroke: Variant = Mouse.stroke_of(params)
+	var stroke: Variant = GdhMouse.stroke_of(params)
 	if stroke is String:
 		return {"type": "error", "message": stroke}
 	var points: Array[Vector2] = stroke
-	var button: int = Mouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
+	var button: int = GdhMouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
-		return Mouse.no_such_button(params.get("button"))
-	var own: int = Mouse.mask_of(button)
+		return GdhMouse.no_such_button(params.get("button"))
+	var own: int = GdhMouse.mask_of(button)
 	if own == 0:
 		return {
 			"type": "error",
 			"message": "A wheel step has no held position to drag from: give left, right or middle."
 		}
-	var frames: int = Read.as_int(params.get("frames", 0), 0)
-	if frames < 1 or frames > Values.MOST_HELD:
+	var frames: int = GdhRead.as_int(params.get("frames", 0), 0)
+	if frames < 1 or frames > GdhValues.MOST_HELD:
 		return {
-			"type": "error", "message": "frames is %d, and it takes 1 to %d." % [frames, Values.MOST_HELD]
+			"type": "error", "message": "frames is %d, and it takes 1 to %d." % [frames, GdhValues.MOST_HELD]
 		}
 
-	var lengths: Array[float] = Mouse.lengths_of(points)
+	var lengths: Array[float] = GdhMouse.lengths_of(points)
 	var start: Vector2 = points[0]
 	var end: Vector2 = points[points.size() - 1]
 	var _moved: Vector2 = _arrive(start)
@@ -418,7 +413,7 @@ func inject_mouse_drag(params: Dictionary) -> Dictionary:
 	var travelled: Vector2 = Vector2.ZERO
 	for step: int in range(1, frames + 1):
 		await _host.get_tree().process_frame
-		var at: Vector2 = Mouse.along(points, lengths, float(step) / frames)
+		var at: Vector2 = GdhMouse.along(points, lengths, float(step) / frames)
 		var relative: Vector2 = _arrive(at)
 		travelled += relative
 		supplied = _follow_in_the_window(at) or supplied
@@ -512,7 +507,7 @@ func click(params: Dictionary) -> Dictionary:
 	var found: Variant = null
 	var item: Variant = null
 	if not wanted.is_empty():
-		var picked: Dictionary = Targets.control_saying(
+		var picked: Dictionary = GdhTargets.control_saying(
 			_host.get_tree().root, "/root" if node_path.is_empty() else node_path, wanted, params.get("index")
 		)
 		if picked.has("message"):
@@ -523,7 +518,7 @@ func click(params: Dictionary) -> Dictionary:
 	if node_path.is_empty():
 		return {"type": "error", "message": "click needs a path, or says to find the control by its words"}
 
-	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"]
@@ -547,7 +542,7 @@ func click(params: Dictionary) -> Dictionary:
 	var item_scrolled: bool = false
 	if item != null:
 		var found_by_words: Dictionary = found
-		var placed_item: Dictionary = await Items.in_view(
+		var placed_item: Dictionary = await GdhItems.in_view(
 			_host.get_tree(), control, node_path, item, wanted, found_by_words
 		)
 		if placed_item.has("message"):
@@ -556,7 +551,7 @@ func click(params: Dictionary) -> Dictionary:
 		item_scrolled = placed_item["scrolled"]
 	var rich: RichTextLabel = control as RichTextLabel
 	if found != null and rich != null:
-		var placed: Dictionary = Targets.point_on_words(rich, wanted)
+		var placed: Dictionary = GdhTargets.point_on_words(rich, wanted)
 		var found_here: Dictionary = found
 		if placed.has("point"):
 			aim = placed["point"]
@@ -584,7 +579,7 @@ func click(params: Dictionary) -> Dictionary:
 	var scrolled: bool = item_scrolled
 	if not _in_sight(control, own, local):
 		scrolled = await _scroll_into_view(control) or item_scrolled
-		var left: String = Values.afterwards(control)
+		var left: String = GdhValues.afterwards(control)
 		if left != "in_tree":
 			return {
 				"type": "error",
@@ -596,7 +591,7 @@ func click(params: Dictionary) -> Dictionary:
 			}
 		local = control.get_global_transform_with_canvas() * aim
 
-	var reached: Dictionary = Screen.reach(own, local)
+	var reached: Dictionary = GdhScreen.reach(own, local)
 	var viewport: Viewport = reached["viewport"]
 	var centre: Vector2 = reached["point"]
 	var position: Vector2 = viewport.get_final_transform() * centre
@@ -607,10 +602,10 @@ func click(params: Dictionary) -> Dictionary:
 	var out_there: String = _out_of_reach(control, node_path, local, reached, scrolled)
 	if not out_there.is_empty():
 		return {"type": "error", "message": out_there}
-	var button: int = Mouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
+	var button: int = GdhMouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
-		return Mouse.no_such_button(params.get("button"))
-	var double: bool = Read.as_bool(params.get("double", false))
+		return GdhMouse.no_such_button(params.get("button"))
+	var double: bool = GdhRead.as_bool(params.get("double", false))
 
 	# Pushed into the viewport rather than through Input: Input accumulates events and flushes
 	# them at the next frame, so the hovered control read below would be the one from before
@@ -659,7 +654,7 @@ func click(params: Dictionary) -> Dictionary:
 	# What became of the control: still in the tree, taken out of it, or freed. A button that
 	# opened another screen is the second or the third, and the caller wants to hear that
 	# rather than guess it from a tree that has changed shape.
-	var afterwards: String = Values.afterwards(control)
+	var afterwards: String = GdhValues.afterwards(control)
 
 	var answer: Dictionary = {
 		"type": "clicked",
@@ -697,11 +692,11 @@ func click(params: Dictionary) -> Dictionary:
 ## what is underneath, which answered `landed: false` with nothing saying why.
 func _takes_no_click(control: Control, node_path: String) -> String:
 	if not control.is_visible_in_tree():
-		return "%s is not visible%s, so nothing can click it" % [node_path, Targets.why_hidden(control)]
+		return "%s is not visible%s, so nothing can click it" % [node_path, GdhTargets.why_hidden(control)]
 	var button: BaseButton = control as BaseButton
 	if button != null and button.disabled:
 		return "%s is disabled, so clicking it presses nothing" % node_path
-	var turned_off: Control = Targets.pointer_turned_off_by(control)
+	var turned_off: Control = GdhTargets.pointer_turned_off_by(control)
 	if turned_off != null:
 		var on: String = "itself" if turned_off == control else str(turned_off.get_path())
 		return (
@@ -713,7 +708,7 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 		)
 	if not control.can_process():
 		var why: String = _why_it_does_not_process(control, node_path)
-		var over: Node = Targets.drawn_over(control)
+		var over: Node = GdhTargets.drawn_over(control)
 		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
 			return (
@@ -778,7 +773,7 @@ func _out_of_reach(
 
 
 func _no_window_note(viewport: Viewport) -> String:
-	return Targets.no_window_note(viewport, _host.get_tree().root)
+	return GdhTargets.no_window_note(viewport, _host.get_tree().root)
 
 
 ## Sends a click's press or release into [param viewport], through Input when that is the game's
@@ -792,7 +787,7 @@ func _no_window_note(viewport: Viewport) -> String:
 ## click meant to open it. Games read that state too, through Input.is_mouse_button_pressed.
 ##
 ## Any other viewport is pushed into directly: Input reaches only the game's window. That is a
-## viewport with no place on the screen, since `Screen.reach` carries every other one there.
+## viewport with no place on the screen, since `GdhScreen.reach` carries every other one there.
 func _press_button(viewport: Viewport, event: InputEventMouseButton) -> void:
 	if viewport == _host.get_tree().root:
 		Input.parse_input_event(event)
@@ -818,10 +813,11 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 	if not item.is_visible_in_tree():
 		return {
 			"type": "error",
-			"message": "%s is not visible%s, so nothing can click it" % [node_path, Targets.why_hidden(item)]
+			"message":
+			"%s is not visible%s, so nothing can click it" % [node_path, GdhTargets.why_hidden(item)]
 		}
 
-	var found: Dictionary = Queries.in_frame(item)
+	var found: Dictionary = GdhQueries.in_frame(item)
 	if found.is_empty():
 		return {
 			"type": "error",
@@ -846,7 +842,7 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 			)
 		}
 
-	var out: Array[Dictionary] = Screen.steps_out(viewport, aim)
+	var out: Array[Dictionary] = GdhScreen.steps_out(viewport, aim)
 	var arriving: Viewport = out.back()["viewport"]
 	var reached_point: Vector2 = out.back()["point"]
 	# Checked where the pointer arrives as well as where the node is drawn: a room in a SubViewport
@@ -862,10 +858,10 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 			)
 		}
 	var position: Vector2 = arriving.get_final_transform() * reached_point
-	var button: int = Mouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
+	var button: int = GdhMouse.button_of(params.get("button", MOUSE_BUTTON_LEFT))
 	if button < 0:
-		return Mouse.no_such_button(params.get("button"))
-	var double: bool = Read.as_bool(params.get("double", false))
+		return GdhMouse.no_such_button(params.get("button"))
+	var double: bool = GdhRead.as_bool(params.get("double", false))
 
 	arriving.push_input(_motion(position, _arrive(position)))
 	var supplied: bool = _hover.follow(arriving, reached_point)
@@ -899,7 +895,7 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 	)
 
 
-## Whether a pointer on its way out through [param out], the steps [method Screen.steps_out]
+## Whether a pointer on its way out through [param out], the steps [method GdhScreen.steps_out]
 ## answers, gets past the interface in every viewport, as {"landed", "hovered"}: the path of the
 ## control that took it, or of the one under it that let it by, or null.
 ##
@@ -984,6 +980,6 @@ func _button(position: Vector2, button: int, pressed: bool, double: bool) -> Inp
 	event.pressed = pressed
 	event.double_click = double
 	var held: int = Input.get_mouse_button_mask()
-	var own: int = Mouse.mask_of(button)
+	var own: int = GdhMouse.mask_of(button)
 	event.button_mask = (held | own) if pressed else (held & ~own)
 	return event

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

@@ -4,12 +4,12 @@ extends RefCounted
 ## a tree row or a menu bar title. Each is drawn by the control rather than held as a node, so a click
 ## on the control's path presses its middle, which is whichever item happens to sit there.
 
-const Says = preload("runtime_says.gd")
-const Values = preload("runtime_values.gd")
-const Words = preload("runtime_words.gd")
+const GdhSays = preload("runtime_says.gd")
+const GdhValues = preload("runtime_values.gd")
+const GdhWords = preload("runtime_words.gd")
 
 
-## Where [param control] draws [param item], one of [method Words.items_of], in the control's own
+## Where [param control] draws [param item], one of [method GdhWords.items_of], in the control's own
 ## space, or an empty rectangle while it draws it nowhere a pointer reaches: a tab scrolled off its
 ## bar, an entry or a row scrolled out of its list, a menu bar the operating system draws. A tree
 ## row is the cell saying [param wanted] when one does, and the whole row otherwise.
@@ -54,7 +54,7 @@ static func item_rect(control: Control, item: Variant, wanted: String) -> Rect2:
 ## does, its cells read together.
 static func tree_column(tree: Tree, row: TreeItem, wanted: String) -> int:
 	for column: int in tree.columns:
-		if Says.matches(Words.cell_says(tree, row, column), wanted):
+		if GdhSays.matches(GdhWords.cell_says(tree, row, column), wanted):
 			return column
 	return -1
 
@@ -96,7 +96,7 @@ static func in_view(
 		if scrolled:
 			# A tree places its rows by the scroll it last drew with.
 			await scene.process_frame
-			var left: String = Values.afterwards(control)
+			var left: String = GdhValues.afterwards(control)
 			if left != "in_tree" or (typeof(item) == TYPE_OBJECT and not is_instance_valid(item)):
 				return {
 					"type": "error",

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

@@ -3,9 +3,9 @@ extends RefCounted
 ## The menu a choice is made from and the item in it, for a choice made by what an item says or by
 ## where it is in the list.
 
-const Read = preload("reading.gd")
-const Says = preload("runtime_says.gd")
-const Words = preload("runtime_words.gd")
+const GdhRead = preload("reading.gd")
+const GdhSays = preload("runtime_says.gd")
+const GdhWords = preload("runtime_words.gd")
 
 
 ## The menu [param node] is, or the one it holds. An [OptionButton] and a [MenuButton] both keep
@@ -38,7 +38,7 @@ static func menu_of(node: Node) -> PopupMenu:
 ## still count after them, for a caller that has the key from the source.
 static func wanted_items(menu: PopupMenu, params: Dictionary) -> Array[int]:
 	if params.has("index"):
-		var asked: int = Read.as_int(params.get("index", -1), -1)
+		var asked: int = GdhRead.as_int(params.get("index", -1), -1)
 		return _items([asked] if asked >= 0 and asked < menu.get_item_count() else [])
 	var wanted: String = str(params.get("text", ""))
 	if wanted.is_empty():
@@ -54,14 +54,14 @@ static func wanted_items(menu: PopupMenu, params: Dictionary) -> Array[int]:
 	var shown: Array[String] = []
 	var held: Array[String] = []
 	for index: int in order:
-		shown.append(Words.item_says(menu, index))
+		shown.append(GdhWords.item_says(menu, index))
 		held.append(menu.get_item_text(index))
 	for words: Array[String] in [shown, held]:
 		for at: int in words.size():
 			if words[at] == wanted:
 				return _items([order[at]])
 		for at: int in words.size():
-			if Says.spaced(words[at]).nocasecmp_to(Says.spaced(wanted)) == 0:
+			if GdhSays.spaced(words[at]).nocasecmp_to(GdhSays.spaced(wanted)) == 0:
 				return _items([order[at]])
 	# Separators are left out here: a heading is refused when named in full, and a pattern that
 	# matched one beside the item it heads would tie the two.
@@ -70,7 +70,7 @@ static func wanted_items(menu: PopupMenu, params: Dictionary) -> Array[int]:
 		var enabled: Array[int] = []
 		for at: int in words.size():
 			var index: int = order[at]
-			if menu.is_item_separator(index) or not Says.matches(words[at], wanted):
+			if menu.is_item_separator(index) or not GdhSays.matches(words[at], wanted):
 				continue
 			matched.append(index)
 			if not menu.is_item_disabled(index):
@@ -93,7 +93,7 @@ static func _items(indices: Array) -> Array[int]:
 static func items_of(menu: PopupMenu) -> Array[String]:
 	var said: Array[String] = []
 	for index: int in menu.get_item_count():
-		var words: String = Words.item_says(menu, index)
+		var words: String = GdhWords.item_says(menu, index)
 		if not menu.is_item_separator(index):
 			said.append("%d: %s" % [index, words])
 		elif not words.strip_edges().is_empty():

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

@@ -3,23 +3,15 @@ extends RefCounted
 ## What a pointer call names: a point, the stroke of a drag, a mouse button and its mask bit. Read
 ## here and sent from runtime_input.gd, which keeps where the pointer is.
 
-const Read = preload("reading.gd")
-
-
-## A point the tool schema sends as two flat numbers, or the older form of one [x, y] value.
-## Answers a Vector2, or the String that says what was wrong with it.
-static func read_point(params: Dictionary, x_key: String, y_key: String, pair_key: String) -> Variant:
-	if params.has(x_key) and params.has(y_key):
-		return Vector2(Read.as_float(params[x_key]), Read.as_float(params[y_key]))
-	var raw: Variant = params.get(pair_key, Vector2.ZERO)
-	if raw is Vector2:
-		return raw
-	if raw is Array:
-		var pair: Array = raw
-		if pair.size() < 2:
-			return "%s array must contain [x, y]" % pair_key
-		return Vector2(Read.as_float(pair[0]), Read.as_float(pair[1]))
-	return "%s must be Vector2 or [x, y]" % pair_key
+const GdhRead = preload("reading.gd")
+
+
+## A point the tool schema sends as two flat numbers. Answers a Vector2, or the String that says
+## which was missing.
+static func read_point(params: Dictionary, x_key: String, y_key: String) -> Variant:
+	if not params.has(x_key) or not params.has(y_key):
+		return "%s and %s are both needed." % [x_key, y_key]
+	return Vector2(GdhRead.as_float(params[x_key]), GdhRead.as_float(params[y_key]))
 
 
 ## The points of a drag: x, y, then each of via, then toX, toY. Answers the String saying what is
@@ -28,7 +20,7 @@ static func stroke_of(params: Dictionary) -> Variant:
 	for key: String in ["x", "y", "toX", "toY"]:
 		if not params.has(key):
 			return "mouse_drag needs x, y, toX and toY: %s is missing." % key
-	var points: Array[Vector2] = [Vector2(Read.as_float(params["x"]), Read.as_float(params["y"]))]
+	var points: Array[Vector2] = [Vector2(GdhRead.as_float(params["x"]), GdhRead.as_float(params["y"]))]
 	var via: Variant = params.get("via", [])
 	if not via is Array:
 		return "via must be a list of [x, y] points."
@@ -37,8 +29,8 @@ static func stroke_of(params: Dictionary) -> Variant:
 		var pair: Array = point if point is Array else []
 		if pair.size() < 2:
 			return "via must be a list of [x, y] points, and holds %s." % JSON.stringify(point)
-		points.append(Vector2(Read.as_float(pair[0]), Read.as_float(pair[1])))
-	points.append(Vector2(Read.as_float(params["toX"]), Read.as_float(params["toY"])))
+		points.append(Vector2(GdhRead.as_float(pair[0]), GdhRead.as_float(pair[1])))
+	points.append(Vector2(GdhRead.as_float(params["toX"]), GdhRead.as_float(params["toY"])))
 	return points
 
 
@@ -108,5 +100,5 @@ static func button_of(raw: Variant) -> int:
 				return -1
 	# The engine's buttons run from 1 to 9: 0 is MOUSE_BUTTON_NONE, which no event carries, and a
 	# number past the two extra buttons names nothing a mask bit can be made for.
-	var number: int = Read.as_int(raw, -1)
+	var number: int = GdhRead.as_int(raw, -1)
 	return number if number >= MOUSE_BUTTON_LEFT and number <= MOUSE_BUTTON_XBUTTON2 else -1

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

@@ -8,8 +8,8 @@ extends RefCounted
 ## reached it as an InputEventAction it never reads, so a controller layout could only be driven by
 ## calling the game's own methods. The engine still fires the actions bound to a button from these.
 
-const Read = preload("reading.gd")
-const Values = preload("runtime_values.gd")
+const GdhRead = preload("reading.gd")
+const GdhValues = preload("runtime_values.gd")
 
 ## Controller buttons by the names Godot gives them, for a caller naming one rather than numbering it.
 const JOY_BUTTONS: Dictionary[String, int] = {
@@ -60,10 +60,10 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 	var button: int = _named_or_numbered(given, JOY_BUTTONS, JOY_BUTTON_MAX)
 	if button < 0:
 		return {"type": "error", "message": _not_one_of("button", given, JOY_BUTTONS, JOY_BUTTON_MAX)}
-	var device: int = Read.as_int(params.get("device", 0), 0)
-	var held: bool = Read.as_bool(params.get("pressed", true), true)
+	var device: int = GdhRead.as_int(params.get("device", 0), 0)
+	var held: bool = GdhRead.as_bool(params.get("pressed", true), true)
 	var whole: bool = not params.has("pressed")
-	var holding: Variant = Values.held_for(params)
+	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
@@ -80,7 +80,7 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 	return {
 		"type": "input_injected",
 		"input_type": "joypad_button",
-		"held_frames": Values.held_answer(whole, frames),
+		"held_frames": GdhValues.held_answer(whole, frames),
 		"button": button,
 		"button_name": _name_of(button, JOY_BUTTONS),
 		"device": device,
@@ -98,12 +98,12 @@ func inject_joypad_motion(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": _not_one_of("axis", given, JOY_AXES, JOY_AXIS_MAX)}
 	if not params.has("value"):
 		return {"type": "error", "message": "joypad_motion needs value, where the axis is, -1 to 1"}
-	var value: float = Read.as_float(params.get("value"), 0.0)
+	var value: float = GdhRead.as_float(params.get("value"), 0.0)
 	if value < -1.0 or value > 1.0:
 		return {
 			"type": "error", "message": "value %s is outside -1 to 1, the whole travel of an axis" % value
 		}
-	var device: int = Read.as_int(params.get("device", 0), 0)
+	var device: int = GdhRead.as_int(params.get("device", 0), 0)
 
 	var event: InputEventJoypadMotion = InputEventJoypadMotion.new()
 	event.axis = axis as JoyAxis
@@ -133,9 +133,9 @@ static func _button(button: int, device: int, down: bool) -> InputEventJoypadBut
 static func _named_or_numbered(given: Variant, names: Dictionary[String, int], count: int) -> int:
 	if given is String:
 		var named: String = given
-		return Read.as_int(names.get(named.strip_edges().to_lower(), -1), -1)
+		return GdhRead.as_int(names.get(named.strip_edges().to_lower(), -1), -1)
 	if given is int or given is float:
-		var number: int = Read.as_int(given, -1)
+		var number: int = GdhRead.as_int(given, -1)
 		return number if number >= 0 and number < count else -1
 	return -1
 

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

@@ -4,8 +4,8 @@ extends RefCounted
 ## run off the game the node keeps. Every op that reads, writes, calls or waits on a game's state
 ## walks the same way, so the walk and what it says when a step is not there live in one place.
 
-const Serialisation = preload("serialisation.gd")
-const Values = preload("runtime_values.gd")
+const GdhSerialisation = preload("serialisation.gd")
+const GdhValues = preload("runtime_values.gd")
 
 ## The calls a path makes on a list or a map: those that take no arguments and change nothing.
 ##
@@ -96,7 +96,7 @@ const READS_ONLY: String = ", and a path, which a wait reads every frame, only c
 ##
 ## A step into a vector, a colour, a rectangle or a transform reads one of its components,
 ## "size:x" or "global_transform:origin:y", by the names GDScript gives them; see
-## [method Serialisation.components_of].
+## [method GdhSerialisation.components_of].
 ##
 ## Answers with a `message` instead when a step along the way is not there or holds something that
 ## is not an object, naming the step rather than the whole path: "/root/Main:_game has no property
@@ -151,7 +151,7 @@ static func object_at(root: Node, node: Node, node_path: String, given: Variant)
 	if path.begins_with("/"):
 		var colon: int = path.find(":")
 		start_path = path if colon == -1 else path.substr(0, colon)
-		var standing: Dictionary = Values.node_at(root, start_path)
+		var standing: Dictionary = GdhValues.node_at(root, start_path)
 		if standing.has("message"):
 			return {"message": str(standing["message"])}
 		start = standing["node"]
@@ -185,7 +185,7 @@ static func can_hold(value: Variant) -> bool:
 ## Whether [param value] is read by its components, a vector or a colour or a transform, and is a
 ## copy wherever it is read from.
 static func composite(value: Variant) -> bool:
-	return not Serialisation.components_of(value).is_empty()
+	return not GdhSerialisation.components_of(value).is_empty()
 
 
 ## Whether [param value] is a packed list. Stepped into the way a list is, by index, and a write into
@@ -235,7 +235,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 			return args.is_empty() and method in MAP_CALLS
 		return not _key_in(map, named).is_empty()
 	if composite(holder):
-		return method.is_empty() and named in Serialisation.components_of(holder)
+		return method.is_empty() and named in GdhSerialisation.components_of(holder)
 	if holder is Object:
 		var object: Object = holder
 		if not method.is_empty():
@@ -620,7 +620,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	if composite(holder):
 		var kind: String = type_string(typeof(holder))
 		var sort: String = ("an " if kind.left(1) in ["A", "E", "I", "O", "U"] else "a ") + kind
-		var has: String = ", ".join(Serialisation.components_of(holder))
+		var has: String = ", ".join(GdhSerialisation.components_of(holder))
 		if not container_call.is_empty():
 			return (
 				"%s is %s, which a path reads by its components, %s, and makes no call on"