gdharness 1.1.46 → 1.1.48

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

@@ -502,9 +502,11 @@ func click(params: Dictionary) -> Dictionary:
 	var landed: bool = hovered == control or (hovered != null and control.is_ancestor_of(hovered))
 
 	# The link a rich label says was pressed, which is its own word for what the press reached.
-	var links: Array[String] = []
-	var heard: Callable = func(meta: Variant) -> void: links.append(str(meta))
-	if rich != null:
+	var links: Array = []
+	var heard: Callable = func(meta: Variant) -> void: links.append(meta)
+	# Read before the press, which may free the label.
+	var on_rich_text: bool = rich != null
+	if on_rich_text:
 		var _listening: int = rich.meta_clicked.connect(heard)
 	_press_button(viewport, _button(position, button, true, double))
 	await _host.get_tree().process_frame
@@ -533,8 +535,12 @@ func click(params: Dictionary) -> Dictionary:
 	}
 	if found != null:
 		answer["found"] = found
-	if not links.is_empty():
-		answer["link_pressed"] = links.back()
+	# Whether a link was pressed apart from what it carries: a bare [url] reports an empty meta,
+	# and given as the meta alone that press read exactly like one that reached no link.
+	if on_rich_text:
+		answer["link_pressed"] = not links.is_empty()
+		if not links.is_empty():
+			answer["link_meta"] = _values.serialize(links.back())
 	return _pointer_noted(answer)
 
 

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

@@ -61,7 +61,7 @@ static func wanted_items(menu: PopupMenu, params: Dictionary) -> Array[int]:
 			if words[at] == wanted:
 				return _items([order[at]])
 		for at: int in words.size():
-			if words[at].nocasecmp_to(wanted) == 0:
+			if Says.spaced(words[at]).nocasecmp_to(Says.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.

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

@@ -16,6 +16,12 @@ const SPLITS_KEPT: int = 8
 ## Each `says` split into alternatives, by what was written; see [method alternatives].
 static var _splits: Dictionary[String, Array] = {}
 
+## Each `says` as the globs [method matches] tries first, by what was written; see [method _loose].
+static var _globs: Dictionary[String, Array] = {}
+
+## Every space separator Unicode has besides the plain space, built once; see [method spaced].
+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:
@@ -34,13 +40,66 @@ static func says(node: Node, wanted: String) -> bool:
 ## wait for the end of a turn is a wait for whichever of "won", "lost" or the next turn's words comes
 ## first, and read as one glob with the bars in it, it waited out its whole timeout for words no
 ## screen says.
+##
+## A space in the words matches any space separator in [param said], which is how they were typed.
+## Each node's words are spaced only once a looser match says they may be the ones: this runs for
+## every node on every look a wait takes, and spacing them all made a look over 16,000 labels half
+## as slow again, which took a game under half its speed on a macOS runner.
 static func matches(said: String, wanted: String) -> bool:
-	for words: String in alternatives(wanted):
-		if said.containsn(words) if is_plain(words) else said.matchn(words):
-			return true
+	for glob: String in _loose(wanted):
+		if said.matchn(glob):
+			var shown: String = spaced(said)
+			for words: String in alternatives(wanted):
+				if shown.containsn(words) if is_plain(words) else shown.matchn(words):
+					return true
+			return false
 	return false
 
 
+## 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
+## 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]:
+	var kept: Variant = _globs.get(wanted)
+	if kept != null:
+		var globs: Array[String] = kept
+		return globs
+	var found: Array[String] = []
+	for words: String in alternatives(wanted):
+		found.append((("*%s*" % words) if is_plain(words) else words).replace(" ", "?"))
+	if _globs.size() >= SPLITS_KEPT:
+		_globs.clear()
+	_globs[wanted] = found
+	return found
+
+
+## [param text] with every Unicode space separator written as a plain space, which is what a caller
+## types for any of them. A game keeping a name on one line writes it with a non-breaking space, and
+## "Deskanem Bonituk" typed with a plain one found nothing while the screen showed exactly those
+## words. One character for one, so a place found in the result is the same place in [param text].
+##
+## Text that is all ASCII holds none of them and is handed back as it is, which is most of a screen.
+## Its UTF-8 is one byte to a character only when every character is ASCII, and counting that costs
+## a quarter of the substitution.
+static func spaced(text: String) -> String:
+	if text.to_utf8_buffer().size() == text.length():
+		return text
+	if _spaces == null:
+		var separators: String = (
+			String.chr(0x00A0)
+			+ String.chr(0x1680)
+			+ String.chr(0x2000)
+			+ "-"
+			+ String.chr(0x200A)
+			+ String.chr(0x202F)
+			+ String.chr(0x205F)
+			+ String.chr(0x3000)
+		)
+		_spaces = RegEx.create_from_string("[%s]" % separators)
+	return _spaces.sub(text, " ", true)
+
+
 ## The alternatives [param wanted] names, each as words on a screen: split at every `|` not written
 ## as `\|`, which stays a bar in the words. An empty alternative, a stray bar at either end, is
 ## dropped: it names no words, and a find that came back empty widened it to `**` and suggested a
@@ -110,4 +169,4 @@ static func widened(wanted: String) -> String:
 ## which reads as a control that is not on the screen. Nothing on a screen says a backslash and
 ## an n, so the two characters mean the break to everybody who writes them.
 static func as_said(wanted: String) -> String:
-	return wanted.replace("\\n", "\n")
+	return spaced(wanted.replace("\\n", "\n"))

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

@@ -41,6 +41,8 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	# The words of the control that matched, which a button pressed on a label's behalf has none of.
 	var said: Array[String] = []
 	var exact: Array[bool] = []
+	# Whether the words are only inside longer words there, "out" in "Scout".
+	var inside: Array[bool] = []
 	var hidden: int = 0
 	# Controls saying exactly the words that a click cannot reach, kept to say what a match on screen
 	# that only says them as part of more stands in for.
@@ -60,14 +62,17 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				var target: Control = _pressed_through(control)
 				var words: String = Words.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)
 				if at == -1:
 					matched.append(target)
 					said.append(words)
 					exact.append(whole)
-				elif whole and not exact[at]:
+					inside.append(buried)
+				elif (whole and not exact[at]) or (inside[at] and not buried):
 					said[at] = words
-					exact[at] = true
+					exact[at] = whole
+					inside[at] = buried
 		var children: Array[Node] = node.get_children(true)
 		for index: int in range(children.size() - 1, -1, -1):
 			pending.push_front(children[index])
@@ -95,9 +100,13 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				out_of_reach_as.append("under %s, which is drawn over it" % over.get_path())
 			if cover == null:
 				cover = over
-	# Stable, so matches of one rank keep the order they are drawn in.
+	# Stable, so matches of one rank keep the order they are drawn in. Words only inside longer words
+	# come after everything else: ranked as a button saying them as part of more, "Scout, 90" was
+	# pressed for "Out" over a control saying exactly "Out", and spent a game's silver.
 	open.sort_custom(
 		func(a: int, b: int) -> bool:
+			if inside[a] != inside[b]:
+				return inside[b]
 			var first: int = _rank(matched[a], exact[a])
 			var second: int = _rank(matched[b], exact[b])
 			return first > second or (first == second and a < b)
@@ -106,11 +115,13 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var ranks: Array[int] = []
 	var lines: Array[String] = []
 	var wholes: Array[bool] = []
+	var insides: Array[bool] = []
 	for index: int in open:
 		targets.append(matched[index])
 		ranks.append(_rank(matched[index], exact[index]))
 		lines.append(said[index])
 		wholes.append(exact[index])
+		insides.append(inside[index])
 
 	var under: String = "" if root_path == "/root" else " under %s" % root_path
 	if targets.is_empty():
@@ -129,7 +140,10 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				]
 			)
 		}
-	var best: int = ranks.count(ranks[0])
+	var best: int = 0
+	for at: int in targets.size():
+		if ranks[at] == ranks[0] and insides[at] == insides[0]:
+			best += 1
 	if which == null and best > 1:
 		var order: String = "" if best == targets.size() else ", best matches first"
 		return {
@@ -151,30 +165,74 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 				% [str(which), targets.size(), plural, under, wanted, _candidates(targets, lines)]
 			)
 		}
-	# A word inside a sentence on screen, while a control saying exactly that word is out of reach: the
-	# sentence is a stand-in, not the control meant. A tab reading "Out" sat in a collapsed drawer, and
-	# a click on it pressed a dispatch saying somebody "fell out in the hall". Pressed only when asked
-	# for by index, which is the caller saying the sentence is what they meant.
-	if which == null and not wholes[index] and not exact_out_of_reach.is_empty():
+	# A match saying the words as part of more, while another control says exactly them, is a stand-in
+	# for that one, not the control meant: a tab reading "Out" sat in a collapsed drawer and a dispatch
+	# saying somebody "fell out in the hall" was pressed, and with the tab's own words on screen in a
+	# control that is not a button, a card reading "Scout, 90" was. Pressed only when asked for by
+	# index, which is the caller saying the match is what they meant.
+	var exact_elsewhere: Array[Node] = exact_out_of_reach.duplicate()
+	var elsewhere_as: Array[String] = out_of_reach_as.duplicate()
+	# On screen only when it takes clicks itself: a heading saying exactly "Onward" beside a button
+	# saying "Onward now" is not what a click on "Onward" is for, and the button is pressed.
+	for other: int in targets.size():
+		var taking: bool = targets[other].get_mouse_filter_with_override() != Control.MOUSE_FILTER_IGNORE
+		if other != index and wholes[other] and taking:
+			exact_elsewhere.append(targets[other])
+			elsewhere_as.append("on screen, taking clicks but not an enabled button")
+	var best_one: String = "the one on screen," if targets.size() == 1 else "the best match on screen,"
+	if which == null and not wholes[index] and not exact_elsewhere.is_empty():
 		return {
 			"type": "error",
 			"message":
 			(
 				(
-					'no control on screen%s says exactly "%s", so nothing was clicked: %s %s says it as part of'
-					+ ' "%s", while %s; pass index %d to press that one anyway, or bring the other into view'
+					'no %s on screen%s says exactly "%s", so nothing was clicked: %s %s says it as part of'
+					+ ' "%s", while %s; pass index %d to press that one anyway'
 				)
 				% [
+					"button" if exact_elsewhere.size() > exact_out_of_reach.size() else "control",
 					under,
 					wanted,
-					"the one on screen," if targets.size() == 1 else "the best match on screen,",
+					best_one,
 					targets[index].get_path(),
 					_shortened(lines[index]),
-					_out_of_reach_exactly(exact_out_of_reach, out_of_reach_as),
+					_out_of_reach_exactly(exact_elsewhere, elsewhere_as),
 					index,
 				]
 			)
 		}
+	if which == null and insides[index]:
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no control on screen%s says "%s" as a word of its own, so nothing was clicked: %s %s has'
+					+ ' it only inside a longer word, "%s"; pass index %d to press that one anyway'
+				)
+				% [under, wanted, best_one, targets[index].get_path(), _shortened(lines[index]), index]
+			)
+		}
+	# Words in a sentence on a control that lets the pointer through: the press lands on whatever is
+	# under it, which is nothing the words name. A line saying what "is out there" was the best match
+	# left for "Out" once the cards saying "Scout" were passed over.
+	if (
+		which == null
+		and not wholes[index]
+		and targets[index].get_mouse_filter_with_override() == Control.MOUSE_FILTER_IGNORE
+	):
+		return {
+			"type": "error",
+			"message":
+			(
+				(
+					'no control on screen%s that takes a click says "%s", so nothing was clicked: %s %s says it'
+					+ ' as part of "%s" and lets the pointer through to what is under it; pass index %d to'
+					+ " click there anyway"
+				)
+				% [under, wanted, best_one, targets[index].get_path(), _shortened(lines[index]), index]
+			)
+		}
 	var found: Dictionary = {"says": wanted, "index": index, "of": targets.size()}
 	if not wholes[index]:
 		found["partOf"] = _shortened(lines[index])
@@ -205,7 +263,8 @@ static func _rank(target: Control, whole: bool) -> int:
 ## A line counts because a card is a title over a description: "WARD" over "wards 3" is the card
 ## 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(said: String, wanted: String) -> bool:
+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):
 			if said.matchn(words):
@@ -220,6 +279,32 @@ static func _says_exactly(said: String, wanted: String) -> bool:
 	return false
 
 
+## Whether [param written] has the plain words [param wanted] asks for only inside longer words,
+## 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 found: bool = false
+	for words: String in Says.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)):
+			return false
+		var at: int = said.find(looked_for)
+		while at >= 0:
+			found = true
+			if at == 0 or not _in_a_word(said.unicode_at(at - 1)):
+				return false
+			at = said.find(looked_for, at + 1)
+	return found
+
+
+## Whether the character [param code] is part of a word: a letter, a digit or an underscore. A letter
+## is told by having a case, which leaves scripts without one counted as breaks between words.
+static func _in_a_word(code: int) -> bool:
+	var character: String = String.chr(code)
+	return character.to_lower() != character.to_upper() or character.is_valid_int() or character == "_"
+
+
 ## [param count] matches of [param rank], as the start of a sentence.
 static func _described(count: int, rank: int, wanted: String, under: String) -> String:
 	var what: String = "button" if rank >= 2 else "control"
@@ -509,7 +594,7 @@ 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 = Words.said_by(label)
+	var text: String = Says.spaced(Words.said_by(label))
 	var start: int = -1
 	var length: int = 0
 	for words: String in Says.alternatives(wanted):

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

@@ -25,7 +25,14 @@ static func said_by(node: Node) -> String:
 		return _label_says(label)
 	if _draws_a_list(node):
 		return "\n".join(lines_said_by(node))
-	return _text_of(node)
+	var own: String = _text_of(node)
+	# A control showing a picture rather than words is named for a player who cannot see it, and that
+	# name is the one the words a caller asks by are meant for: the rail's "Out" tab is a square with
+	# an icon on it, and a click on "Out" found only the words around it.
+	if own.is_empty() and node is Control:
+		var control: Control = node
+		return control.atr(control.accessibility_name).strip_edges()
+	return own
 
 
 ## Every line [param node] draws for a player to read, one to an entry: a label's one line, or each