gdharness 1.3.8 → 1.3.9

package/build/godot/operations/project_config.gd

@@ -166,6 +166,37 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	return answer
 
 
+# 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 answer
+	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 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/reading.gd

@@ -24,6 +24,23 @@ extends RefCounted
 
 ## How many of a node's children a refusal for a path missing below it names.
 const NAMED_CHILDREN: int = 12
+## The types holding their floats as the engine's real numbers, 32-bit unless it was built for 64.
+const SHAPES_OF_REALS: Array[int] = [
+	TYPE_VECTOR2,
+	TYPE_VECTOR3,
+	TYPE_VECTOR4,
+	TYPE_RECT2,
+	TYPE_PLANE,
+	TYPE_QUATERNION,
+	TYPE_AABB,
+	TYPE_BASIS,
+	TYPE_TRANSFORM2D,
+	TYPE_TRANSFORM3D,
+	TYPE_PROJECTION,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+]
 
 
 static func as_int(value: Variant, fallback: int = 0) -> int:
@@ -190,18 +207,26 @@ static func offered(said: String, word: String, names: Array) -> String:
 
 
 ## [param said], the refusal for [param property], which [param target] does not declare, with the
-## names it declares nearest it when any are, as a misspelt one is usually one of them. Unlike
-## [method offered], nothing is listed when none is near, since an object declares a hundred.
+## names it declares nearest it when any are, as a misspelt one is usually one of them, or else the
+## variables its script declares. The engine's own are not listed when none is near, since an object
+## has a hundred, while a script's are the few a caller most likely meant.
 static func near_property(said: String, target: Object, property: String) -> String:
 	var headings: int = PROPERTY_USAGE_CATEGORY | PROPERTY_USAGE_GROUP | PROPERTY_USAGE_SUBGROUP
 	var names: Array[String] = []
+	var scripted: Array[String] = []
 	for declared: Dictionary in target.get_property_list():
-		if not as_int(declared.get("usage", 0)) & headings:
+		var usage: int = as_int(declared.get("usage", 0))
+		if not usage & headings:
 			names.append(str(declared.get("name", "")))
+		if usage & PROPERTY_USAGE_SCRIPT_VARIABLE and not usage & headings:
+			scripted.append(str(declared.get("name", "")))
 	var close: PackedStringArray = nearest(property, PackedStringArray(names))
-	if close.is_empty():
+	if not close.is_empty():
+		return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if scripted.is_empty():
 		return said
-	return "%s; the nearest it has %s %s" % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	scripted.sort()
+	return "%s; its script declares %s" % [said, ", ".join(PackedStringArray(scripted))]
 
 
 ## The signals [param object] has that a caller can connect, its own class's first: the engine
@@ -219,3 +244,34 @@ static func signals_of(object: Object) -> Array:
 ## [param word] after the article it takes, "an AnimationTree" or "a Node2D".
 static func with_article(word: String) -> String:
 	return ("an " if word.left(1).to_upper() in ["A", "E", "I", "O", "U"] else "a ") + word
+
+
+## [param value], which the engine holds as a 32-bit float, as the shortest decimal that is still
+## that float. JSON carries a double, and the double a 32-bit 0.2 widens to is 0.200000002980232:
+## the same number, but not the one written or the one the file shows, so a caller comparing what it
+## set against what it read saw them differ. The shorter one, sent back, stores the same 32 bits. A
+## plain float is left alone by the serialiser, since nothing says whether the engine holds it in
+## 32 bits or 64.
+static func single(value: float) -> float:
+	if not is_finite(value) or value == 0.0:
+		return value
+	var held: float = PackedFloat32Array([value])[0]
+	var magnitude: int = floori(log(absf(held)) / log(10.0))
+	for digits: int in range(1, 10):
+		var shift: int = digits - 1 - magnitude
+		var tried: float = (
+			roundf(held * pow(10.0, shift)) / pow(10.0, shift)
+			if shift >= 0
+			else roundf(held / pow(10.0, -shift)) * pow(10.0, -shift)
+		)
+		if PackedFloat32Array([tried])[0] == held:
+			return tried
+	return held
+
+
+## Whether a value of [param type] holds its floats in 32 bits: a colour always, and the vectors and
+## the shapes built of them unless the engine was built for 64.
+static func holds_singles(type: int) -> bool:
+	if type in [TYPE_COLOR, TYPE_PACKED_COLOR_ARRAY, TYPE_PACKED_FLOAT32_ARRAY]:
+		return true
+	return not OS.has_feature("double") and type in SHAPES_OF_REALS

package/build/godot/operations/serialisation.gd

@@ -142,28 +142,29 @@ func serialize_value(value: Variant) -> Variant:
 		return value
 	var carried: Variant = call(serialiser, value)
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
-	# tagged here; containers reach their members through this function already.
-	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
+	var type: int = typeof(value)
+	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
 # NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
 # back out as null, so a property holding INF was answered as holding nothing.
-func _finite(carried: Variant) -> Variant:
+func _finite(carried: Variant, single: bool = false) -> Variant:
 	if carried is float:
 		var number: float = carried
-		return _serialize_float(number)
+		return _serialize_float(GdhRead.single(number) if single else number)
 	if carried is Dictionary:
 		var fields: Dictionary = carried
 		var tagged: Dictionary = {}
 		for key: Variant in fields:
-			tagged[key] = _finite(fields[key])
+			tagged[key] = _finite(fields[key], single)
 		return tagged
 	if carried is Array:
 		var items: Array = carried
 		var tagged_items: Array = []
 		for item: Variant in items:
-			tagged_items.append(_finite(item))
+			tagged_items.append(_finite(item, single))
 		return tagged_items
 	return carried
 
@@ -189,7 +190,7 @@ func _serialize_floats(value: Variant) -> Variant:
 			for each: float in numbers:
 				items.append(_serialize_float(each))
 			return items
-	return value
+	return numbers if value is PackedFloat32Array else value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.

package/build/keeper.js

@@ -814,11 +814,13 @@ class GameDebugger {
   server;
   port;
   breakpoints;
+  breakpointLines;
   observers;
   constructor(server, port, breakpoints, observers) {
     this.server = server;
     this.port = port;
     this.breakpoints = breakpoints;
+    this.breakpointLines = new Set(breakpoints);
     this.observers = observers;
   }
   static async open(breakpoints, observers = []) {
@@ -1010,6 +1012,11 @@ class GameDebugger {
     }
     switch (request.op) {
       case "breakpoint":
+        if (request.set) {
+          this.breakpointLines.add(`${request.script}:${String(request.line)}`);
+        } else {
+          this.breakpointLines.delete(`${request.script}:${String(request.line)}`);
+        }
         this.send("breakpoint", [request.script, request.line, request.set], this.held?.thread ?? MAIN_THREAD);
         return { sent: true };
       case "pause":
@@ -1087,18 +1094,12 @@ class GameDebugger {
         };
       }
     }
-    let frames = await this.stack();
-    const stepping = Date.now();
-    while (frames !== null && this.held !== null && (frames[0]?.script.startsWith(RUNTIME_ADDON) ?? false) && Date.now() - stepping < ADDON_STEP_MS) {
-      this.forget("debug_enter");
-      this.send("step", [], this.held.thread);
-      if (await this.next(GameDebugger.named("debug_enter"), STEP_MS) === null) {
-        return {
-          paused: false,
-          note: `The game stopped in gdharness's runtime addon and was stepped on to reach its own script, and did not stop again within ${STEP_MS / 1000}s. It stops at the next line of script it runs; debug_state stack reads it then.`
-        };
-      }
-      frames = await this.stack();
+    const frames = await this.pastTheAddon();
+    if (frames === "lost") {
+      return {
+        paused: false,
+        note: `The game stopped in gdharness's runtime addon and was stepped on to reach its own script, and did not stop again within ${STEP_MS / 1000}s. It stops at the next line of script it runs; debug_state stack reads it then.`
+      };
     }
     this.stoppedBy("Paused");
     const stack = frames ?? [];
@@ -1111,6 +1112,19 @@ class GameDebugger {
       } : {}
     };
   }
+  async pastTheAddon() {
+    let frames = await this.stack();
+    const stepping = Date.now();
+    while (frames !== null && this.held !== null && (frames[0]?.script.startsWith(RUNTIME_ADDON) ?? false) && Date.now() - stepping < ADDON_STEP_MS) {
+      this.forget("debug_enter");
+      this.send("step", [], this.held.thread);
+      if (await this.next(GameDebugger.named("debug_enter"), STEP_MS) === null) {
+        return "lost";
+      }
+      frames = await this.stack();
+    }
+    return frames;
+  }
   stoppedBy(cause) {
     if (this.held !== null) {
       this.held = { ...this.held, reason: cause };
@@ -1139,8 +1153,24 @@ class GameDebugger {
         note: `The game had not stopped again ${STEP_MS / 1000}s after the step: the step is still running, as one out of a function that never returns does, or it went on without reaching another line. debug_state stack answers once it stops, and debug_control pause stops it wherever it is.`
       };
     }
+    const frames = await this.pastTheAddon();
+    if (frames === "lost") {
+      return {
+        stepped: true,
+        heldAgain: false,
+        note: `The step stopped in gdharness's runtime addon and was stepped on to reach the game's own script, and did not stop again within ${STEP_MS / 1000}s. It stops at the next line of script the game runs; debug_state stack reads it then.`
+      };
+    }
     this.stoppedBy("Stepped");
-    return { stepped: true, heldAgain: true, held: this.heldState(), stack: await this.stack() ?? [] };
+    const stack = frames ?? [];
+    const top = stack[0];
+    const onBreakpoint = top !== undefined && this.breakpointLines.has(`${top.script}:${String(top.line)}`);
+    return {
+      stepped: true,
+      heldAgain: true,
+      held: { ...this.heldState(), ...onBreakpoint ? { onBreakpoint: true } : {} },
+      stack
+    };
   }
   async variables(frame) {
     const held = this.held;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.8",
+  "version": "1.3.9",
   "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",