gdharness 1.0.24 → 1.0.25

package/build/cli.js

@@ -16779,7 +16779,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+          description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
         },
         includeHidden: {
           type: "boolean",

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

@@ -379,11 +379,17 @@ static func _drawn(node: Node) -> bool:
 ## Public because three questions are the same question: what a screen reads as, which nodes say a
 ## given word, and whether anything has come to say it yet. Two copies of what a node says is how
 ## the three of them come to disagree about a SpinBox.
+##
+## Read rather than looked up in the property list, which the engine builds afresh on every call: a
+## wait asks this of every node on the screen every frame, and on a hall of 3,500 nodes the lookup
+## took the game it was watching from 60 frames a second to 11. A node without the property reads
+## as null, which is not a string.
 static func said_by(node: Node) -> String:
-	for property: Dictionary in node.get_property_list():
-		if str(property.get("name", "")) == "text" and Read.as_int(property.get("type", 0)) == TYPE_STRING:
-			return str(node.get("text")).strip_edges()
-	return ""
+	var text: Variant = node.get("text")
+	if not text is String:
+		return ""
+	var words: String = text
+	return words.strip_edges()
 
 
 func get_rect(params: Dictionary) -> Dictionary:

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

@@ -15,6 +15,10 @@ const CEILING_MSEC: int = 120000
 ## The most frames one wait may cover, which is about half a minute of a game drawing slowly.
 const MOST_FRAMES: int = 600
 
+## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
+## gives looking about a tenth of the time.
+const LOOKS_APART: int = 9
+
 var _host: Node
 var _values: Values
 
@@ -140,6 +144,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": refused}
 
 	var started: int = Time.get_ticks_msec()
+	var frames: int = 0
 	# The type is checked every time round, not only at the top: a property that holds an object a
 	# frame later is the same error arriving late.
 	while (
@@ -148,6 +153,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		and Time.get_ticks_msec() - started < timeout_ms
 	):
 		await _host.get_tree().process_frame
+		frames += 1
 		if not is_instance_valid(node):
 			return {"type": "error", "message": "%s was freed while waiting" % node_path}
 		watched = _watched(node, node_path, property)
@@ -162,6 +168,7 @@ func wait_until(params: Dictionary) -> Dictionary:
 		"met": Values.comparable(current, wanted) and current == wanted,
 		"value": _values.serialize(current),
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
 	}
 
 
@@ -232,13 +239,36 @@ static func _watched(node: Node, node_path: String, property: String) -> Diction
 ## answered met in two milliseconds while the sweep was still animating, and every wait on that
 ## screen fell back to counting frames. [param include_hidden] asks the other question, for a
 ## caller waiting on words a hidden node holds.
+##
+## Paced by what a look costs, so the watching leaves the game its speed: every frame while a look is
+## cheap, and on a screen large enough for one to cost a real share of a frame, often enough that
+## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
+## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
+## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
+## The answer says how many frames the wait spanned and how many looks it took, which is how a
+## caller sees what it cost.
 func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_hidden: bool) -> Dictionary:
 	var started: int = Time.get_ticks_msec()
 	var words: String = Queries.as_said(said)
-	var found: bool = _anything_says(node_path, words, include_hidden)
-	while not found and Time.get_ticks_msec() - started < timeout_ms:
+	var frames: int = 0
+	var looks: int = 0
+	var next_look: int = 0
+	var found: bool = false
+	while true:
+		if Time.get_ticks_usec() >= next_look:
+			var looking: int = Time.get_ticks_usec()
+			found = _anything_says(node_path, words, include_hidden)
+			looks += 1
+			next_look = Time.get_ticks_usec() + (Time.get_ticks_usec() - looking) * LOOKS_APART
+		if found or Time.get_ticks_msec() - started >= timeout_ms:
+			break
 		await _host.get_tree().process_frame
+		frames += 1
+	# One more look at the end, so words that arrived between two paced looks are not answered as
+	# never having come.
+	if not found:
 		found = _anything_says(node_path, words, include_hidden)
+		looks += 1
 
 	return {
 		"type": "condition",
@@ -247,6 +277,8 @@ func _wait_until_said(node_path: String, said: String, timeout_ms: int, include_
 		"met": found,
 		"include_hidden": include_hidden,
 		"elapsed_ms": Time.get_ticks_msec() - started,
+		"frames": frames,
+		"looks": looks,
 	}
 
 

package/build/index.js

@@ -30786,7 +30786,7 @@ var TOOL_SPECS = [
       says: {
         type: "string",
         ops: ["until"],
-        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+        description: "until: wait for these words to appear anywhere under nodePath, or anywhere in the game when no nodePath is given, instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property. It looks every frame while a look is cheap and less often on a screen large enough for a look to cost a real share of a frame, so the game keeps its speed; the answer counts the frames the wait spanned and the looks it took."
       },
       includeHidden: {
         type: "boolean",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",