gdharness 1.1.21 → 1.1.23

package/build/godot/operations/serialisation.gd

@@ -53,6 +53,9 @@ const LIST_TYPES: Array[int] = [
 # type it wanted.
 const SERIALISERS: Dictionary = {
 	TYPE_NIL: "_serialize_nil",
+	TYPE_FLOAT: "_serialize_float",
+	TYPE_PACKED_FLOAT32_ARRAY: "_serialize_floats",
+	TYPE_PACKED_FLOAT64_ARRAY: "_serialize_floats",
 	TYPE_VECTOR2: "_serialize_vector2",
 	TYPE_VECTOR2I: "_serialize_vector2i",
 	TYPE_VECTOR3: "_serialize_vector3",
@@ -105,6 +108,8 @@ const BUILDERS: Dictionary = {
 	"Color": "_build_color",
 	"NodePath": "_build_node_path",
 	"PackedByteArray": "_build_bytes",
+	"float": "_build_float",
+	"Dictionary": "_build_dictionary",
 }
 
 # What each tag has to carry before it is built. A tag naming a type whose keys are not there is a
@@ -130,6 +135,8 @@ const REQUIRED: Dictionary = {
 	"Color": [["r", "g", "b"]],
 	"NodePath": [["path"]],
 	"PackedByteArray": [["base64"]],
+	"float": [["value"]],
+	"Dictionary": [["entries"]],
 }
 
 
@@ -145,7 +152,58 @@ func serialize_value(value: Variant) -> Variant:
 	if typeof(value) == TYPE_OBJECT and not is_instance_valid(value):
 		return null
 	var serialiser: String = SERIALISERS.get(typeof(value), "")
-	return call(serialiser, value) if not serialiser.is_empty() else value
+	if serialiser.is_empty():
+		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)
+
+
+# [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:
+	if carried is float:
+		var number: float = carried
+		return _serialize_float(number)
+	if carried is Dictionary:
+		var fields: Dictionary = carried
+		var tagged: Dictionary = {}
+		for key: Variant in fields:
+			tagged[key] = _finite(fields[key])
+		return tagged
+	if carried is Array:
+		var items: Array = carried
+		var tagged_items: Array = []
+		for item: Variant in items:
+			tagged_items.append(_finite(item))
+		return tagged_items
+	return carried
+
+
+func _serialize_float(value: float) -> Variant:
+	if is_finite(value):
+		return value
+	return {"_type": "float", "value": "nan" if is_nan(value) else ("inf" if value > 0 else "-inf")}
+
+
+# A packed float array stays the JSON list it is unless something in it has no JSON spelling.
+func _serialize_floats(value: Variant) -> Variant:
+	var numbers: Array = []
+	if value is PackedFloat32Array:
+		var single: PackedFloat32Array = value
+		numbers = Array(single)
+	else:
+		var double: PackedFloat64Array = value
+		numbers = Array(double)
+	for number: float in numbers:
+		if not is_finite(number):
+			var items: Array = []
+			for each: float in numbers:
+				items.append(_serialize_float(each))
+			return items
+	return value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.
@@ -181,9 +239,27 @@ func deserialize_value(value: Variant) -> Variant:
 	var needed: Array = REQUIRED.get(tag, [])
 	if builder.is_empty() or not _carries(fields, needed):
 		return fields
+	if tag == "float" and str(fields["value"]) not in ["inf", "-inf", "nan"]:
+		return fields
+	if tag == "Dictionary" and not pairs(fields["entries"]):
+		return fields
 	return call(builder, fields)
 
 
+## Whether [param entries] is a list of [key, value] pairs, as a Dictionary tag carries them.
+static func pairs(entries: Variant) -> bool:
+	if not entries is Array:
+		return false
+	var listed: Array = entries
+	for entry: Variant in listed:
+		if not entry is Array:
+			return false
+		var pair: Array = entry
+		if pair.size() != 2:
+			return false
+	return true
+
+
 ## Whether two values can be compared without the comparison itself failing.
 ##
 ## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
@@ -193,16 +269,19 @@ func deserialize_value(value: Variant) -> Variant:
 ## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
 ## session's game.
 ##
-## Only an object is special. Every other pair the engine answers, false where they differ, and
-## refusing those would refuse calls that work: an int against a float is the same number to a
-## caller waiting for 1 on a property holding 1.0.
+## Measured on 4.7.2 over every pair of built-in types: two values of different types compare only
+## as an int against a float, a String against a StringName, or anything against null. Every other
+## pair is that error, a word against a number as much as an object against a word, and so is a bool
+## against an int and a NodePath against a String. An int against a float is kept because it is the
+## same number to a caller waiting for 1 on a property holding 1.0.
 static func comparable(one: Variant, other: Variant) -> bool:
 	var left: int = typeof(one)
 	var right: int = typeof(other)
-	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+	if left == right or left == TYPE_NIL or right == TYPE_NIL:
 		return true
-	# An object compares with another object and with null. Anything else is the error above.
-	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+	var numbers: Array[int] = [TYPE_INT, TYPE_FLOAT]
+	var texts: Array[int] = [TYPE_STRING, TYPE_STRING_NAME]
+	return (left in numbers and right in numbers) or (left in texts and right in texts)
 
 
 ## Whether [param value] can be given to something declared as [param type] without damage.
@@ -400,7 +479,16 @@ func _serialize_signal(value: Signal) -> Dictionary:
 	return described
 
 
+## A dictionary keyed by text as itself, and any other as its entries. JSON keys are text, so an
+## int or Vector2 key was answered as its text, and a dictionary read and written back had its keys
+## replaced by words: `{1: "a"}` came back as `{"1": "a"}`.
 func _serialize_dictionary(value: Dictionary) -> Dictionary:
+	var texts: bool = value.keys().all(func(key: Variant) -> bool: return key is String or key is StringName)
+	if not texts:
+		var entries: Array = []
+		for key: Variant in value:
+			entries.append([serialize_value(key), serialize_value(value[key])])
+		return {"_type": "Dictionary", "entries": entries}
 	var serialised: Dictionary = {}
 	for key: Variant in value:
 		serialised[str(key)] = serialize_value(value[key])
@@ -621,6 +709,27 @@ func _build_bytes(fields: Dictionary) -> PackedByteArray:
 	return Marshalls.base64_to_raw(str(fields.get("base64", "")))
 
 
+func _build_float(fields: Dictionary) -> float:
+	return Read.as_float(fields)
+
+
+## The entries of a dictionary whose keys are not all text. JSON carries every number as a float,
+## and a dictionary keys 1.0 apart from 1, so a whole-number key is built as an int: the key a
+## game uses far more often, and one JSON cannot tell from the float.
+func _build_dictionary(fields: Dictionary) -> Dictionary:
+	var built: Dictionary = {}
+	var entries: Array = fields["entries"]
+	for entry: Variant in entries:
+		var pair: Array = entry
+		var key: Variant = deserialize_value(pair[0])
+		if key is float:
+			var number: float = key
+			if is_finite(number) and number == floorf(number):
+				key = int(number)
+		built[key] = deserialize_value(pair[1])
+	return built
+
+
 ## One component of a compound value, as the type its constructor wants.
 ##
 ## Their own functions because a constructor refuses a Variant under `unsafe_call_argument`, and