jpmschweitzerandClaude Opus 4.6
b5dd44313e
Protocol.gd decodes ObserverSnapshot and PlayerInput from Rust's rmp_serde wire format, and encodes PlayerInput for sending to server. Handles rmp_serde enum encoding: unit variants as bare strings, data variants as single-element maps. 8 fixture-based tests verify decode of Rust-generated fixtures, GDScript encode/decode roundtrips, and cross-language compatibility. All 15 tests pass (3 suites). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
115 lines
3.9 KiB
GDScript
115 lines
3.9 KiB
GDScript
class_name Protocol
|
|
## MessagePack codec for the Rust↔Godot wire protocol (D-020).
|
|
##
|
|
## Encodes/decodes ObserverSnapshot and PlayerInput to match
|
|
## rmp_serde's named-field encoding of server/src/bridge/types.rs.
|
|
##
|
|
## Wire format notes (rmp_serde with to_vec_named):
|
|
## Structs → msgpack maps with string keys
|
|
## Unit enum variants (no data) → bare strings ("MoveNorth", "Npc")
|
|
## Data enum variants → single-element maps ({"UsePerceptionMode": "thermal"})
|
|
|
|
|
|
# -- Decode: bytes from server → GDScript types --------------------------------
|
|
|
|
## Decode an ObserverSnapshot from MessagePack bytes.
|
|
## Returns { "tick": int, "entities": Array[Dictionary] } or null on error.
|
|
static func decode_snapshot(bytes: PackedByteArray) -> Variant:
|
|
var result = Messagepack.decode(bytes)
|
|
if result.status != null:
|
|
push_error("Protocol: msgpack decode failed: %s" % result.status)
|
|
return null
|
|
|
|
var raw = result.value
|
|
if not raw is Dictionary or not raw.has("tick") or not raw.has("entities"):
|
|
push_error("Protocol: snapshot missing required fields")
|
|
return null
|
|
|
|
var entities: Array[Dictionary] = []
|
|
for raw_entity in raw["entities"]:
|
|
var entity = _decode_entity(raw_entity)
|
|
if entity != null:
|
|
entities.append(entity)
|
|
|
|
return {
|
|
"tick": int(raw["tick"]),
|
|
"entities": entities,
|
|
}
|
|
|
|
|
|
## Decode a single VisibleEntity from a raw msgpack map.
|
|
static func _decode_entity(raw: Dictionary) -> Variant:
|
|
if not raw.has("entity_id") or not raw.has("x") or not raw.has("y") \
|
|
or not raw.has("z") or not raw.has("kind"):
|
|
push_warning("Protocol: entity missing required fields: %s" % str(raw.keys()))
|
|
return null
|
|
|
|
return {
|
|
"entity_id": int(raw["entity_id"]),
|
|
"x": float(raw["x"]),
|
|
"y": float(raw["y"]),
|
|
"z": int(raw["z"]),
|
|
"kind": _decode_enum_variant(raw["kind"]),
|
|
}
|
|
|
|
|
|
## Decode an enum variant from rmp_serde's encoding.
|
|
## Unit variants are bare strings, data variants are single-element maps.
|
|
## Returns { "variant": String, "data": Variant } in both cases.
|
|
static func _decode_enum_variant(raw) -> Dictionary:
|
|
if raw is String:
|
|
return { "variant": raw, "data": null }
|
|
elif raw is Dictionary and raw.size() == 1:
|
|
var variant_name: String = raw.keys()[0]
|
|
return { "variant": variant_name, "data": raw[variant_name] }
|
|
else:
|
|
push_warning("Protocol: unexpected enum encoding: %s" % str(raw))
|
|
return { "variant": "Unknown", "data": raw }
|
|
|
|
|
|
# -- Encode: GDScript types → bytes to server ----------------------------------
|
|
|
|
## Encode a PlayerInput to MessagePack bytes.
|
|
## action_name: one of "MoveNorth", "MoveSouth", "MoveEast", "MoveWest",
|
|
## "Interact", "UsePerceptionMode", "Pause", "Unpause"
|
|
## action_data: null for unit variants, String for UsePerceptionMode
|
|
static func encode_player_input(tick: int, action_name: String, action_data: Variant = null) -> PackedByteArray:
|
|
var action_value: Variant
|
|
if action_data != null:
|
|
# Data variant → single-element map
|
|
action_value = { action_name: action_data }
|
|
else:
|
|
# Unit variant → bare string
|
|
action_value = action_name
|
|
|
|
var input := {
|
|
"tick": tick,
|
|
"action": action_value,
|
|
}
|
|
|
|
var result = Messagepack.encode(input)
|
|
if result.status != null:
|
|
push_error("Protocol: msgpack encode failed: %s" % result.status)
|
|
return PackedByteArray()
|
|
|
|
return result.value
|
|
|
|
|
|
## Decode a PlayerInput from MessagePack bytes (used in tests / echo scenarios).
|
|
## Returns { "tick": int, "action": { "variant": String, "data": Variant } } or null.
|
|
static func decode_player_input(bytes: PackedByteArray) -> Variant:
|
|
var result = Messagepack.decode(bytes)
|
|
if result.status != null:
|
|
push_error("Protocol: msgpack decode failed: %s" % result.status)
|
|
return null
|
|
|
|
var raw = result.value
|
|
if not raw is Dictionary or not raw.has("tick") or not raw.has("action"):
|
|
push_error("Protocol: player_input missing required fields")
|
|
return null
|
|
|
|
return {
|
|
"tick": int(raw["tick"]),
|
|
"action": _decode_enum_variant(raw["action"]),
|
|
}
|