styly-netsync-server 0.10.4__tar.gz → 0.12.0__tar.gz

{styly_netsync_server-0.10.4 → styly_netsync_server-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.10.4
+Version: 0.12.0
 Summary: STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences
 Author-email: "STYLY, Inc." <info@styly.inc>
 License-Expression: Apache-2.0
@@ -81,12 +81,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 3`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V3 pose body.
-- Legacy transform protocol v2 and JSON transform fallback are not supported.
+- Current transform wire protocol is `protocolVersion = 5`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
+- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
+- Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v3 position quantization ranges:
-  - Absolute (`physicalPos`, `headPosAbs`): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+- Protocol v5 position quantization ranges:
+  - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+  - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
   - Head-relative (`right/left/virtual`): signed `int16` at `0.005 m` per unit, per-axis range `[-163.84 m, 163.835 m]`.
 - These are encoding limits, not a hard world-size cap. Worlds can be larger, but encoded axis values are clamped if they exceed the representable range.
 
@@ -94,18 +98,18 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed baseline (`protocolVersion=3`):
-- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `49 bytes`
-- Room per-client entry (`clientNo + poseTime + clientBody`): `59 bytes`
+Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
+- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
+- Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 
 | Option | Absolute Position Encoding | Per-axis Range | Client Body Delta | Room Per-client Delta |
 |---|---|---:|---:|---:|
-| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`49 -> 49`) | `+0B` (`59 -> 59`) |
-| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
-| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
+| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`46 -> 46`) | `+0B` (`56 -> 56`) |
+| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
+| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
 
 Notes:
-- Option B/C deltas assume both absolute transforms are present (`physicalPos` and `headPosAbs`).
+- Only `headPosAbs` is on the wire as an absolute field; `physicalPos` is reconstructed from `headPosAbs + xrOriginDelta`. Option B/C deltas therefore apply to `headPosAbs` only.
 - Option B/C can reduce average overhead if `cell` is transmitted only when changed, but that requires extra state and flags in the wire format.
 
 ## Configuration
@@ -160,7 +164,7 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 
 ```json
 {
-  "vars": {
+  "variables": {
     "name": "Jack",
     "lang": "EN"
   }
@@ -179,11 +183,35 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"name":"Jack","lang":"EN"}}'
+  -d '{"variables":{"name":"Jack","lang":"EN"}}'
 ```
 
 The response includes the current mapping status (`clientNo` or `null`) and whether each key was `"applied"` or `"queued"`.
 
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables` — returns all client variables for the device.
+
+    ```json
+    {"clientNo": 7, "variables": {"name": "Jack", "lang": "EN"}}
+    ```
+
+    If the device has no `clientNo` mapping yet, returns `{"clientNo": null, "variables": {}}`.
+
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables/{name}` — returns a single variable.
+
+    ```json
+    {"clientNo": 7, "value": "Jack"}
+    ```
+
+    Returns `404` if the device is unmapped or the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables/name"
+  ```
+
 ### Global variables
 
 - Endpoint: `POST /v1/rooms/{roomId}/global-variables`
@@ -191,7 +219,7 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 
 ```json
 {
-  "vars": {
+  "variables": {
     "score": "42",
     "stage": "lobby"
   }
@@ -210,7 +238,33 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/global-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"score":"42","stage":"lobby"}}'
+  -d '{"variables":{"score":"42","stage":"lobby"}}'
 ```
 
 The response includes the room ID and whether each key was `"applied"`, `"queued"`, or `"failed"`.
+
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/global-variables` — returns all global variables for the room.
+
+    ```json
+    {"variables": {"score": "42", "stage": "lobby"}}
+    ```
+
+  - `GET /v1/rooms/{roomId}/global-variables/{name}` — returns a single variable.
+
+    ```json
+    {"value": "42"}
+    ```
+
+    Returns `404` if the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables/score"
+  ```
+
+### Read consistency
+
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.

{styly_netsync_server-0.10.4 → styly_netsync_server-0.12.0}/README.md

@@ -42,12 +42,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 3`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V3 pose body.
-- Legacy transform protocol v2 and JSON transform fallback are not supported.
+- Current transform wire protocol is `protocolVersion = 5`.
+- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V5 pose body.
+- v5 adds an optional `MovingFloorLocal` pose flag. Bound avatars send head, hands, and virtual transforms in the registered moving floor's local coordinates, and reuse the existing 8-byte physical slot as direct physical position/yaw.
+- Unbound v5 poses keep the v4 `xrOriginDelta` semantics: `xrOriginDelta` carries a Y component as a 4th `int16` (`dx, dy, dz, dyaw` = 8 bytes vs. v3's 6), so receivers can reconstruct the sender's rig-Y motion.
+- Legacy transform protocols (v2/v3) and JSON transform fallback are not supported.
 - Deploy Unity and Python updates together when changing transform protocol behavior.
-- Protocol v3 position quantization ranges:
-  - Absolute (`physicalPos`, `headPosAbs`): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+- Protocol v5 position quantization ranges:
+  - Absolute (`headPosAbs` only): signed `int24` at `0.01 m` per unit, per-axis range `[-83,886.08 m, 83,886.07 m]`.
+  - XROrigin locomotion delta for unbound poses (`xrOriginDelta`, 4×`int16`: `dx, dy, dz, dyaw`): `0.01 m` per unit for translation, `0.1°` for yaw. Receivers reconstruct `physicalPos = invDeltaRot * (headPos − deltaPos)`; it is not on the wire as a separate absolute field.
+  - Direct physical payload for moving-floor-local poses (`physical`, 4×`int16`: `x, y, z, yaw`): `0.01 m` per unit for translation, `0.1°` for yaw.
   - Head-relative (`right/left/virtual`): signed `int16` at `0.005 m` per unit, per-axis range `[-163.84 m, 163.835 m]`.
 - These are encoding limits, not a hard world-size cap. Worlds can be larger, but encoded axis values are clamped if they exceed the representable range.
 
@@ -55,18 +59,18 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 The following options summarize trade-offs when expanding absolute-position range.
 
-Assumed baseline (`protocolVersion=3`):
-- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `49 bytes`
-- Room per-client entry (`clientNo + poseTime + clientBody`): `59 bytes`
+Assumed unbound baseline (`protocolVersion=5`, `MovingFloorLocal` off):
+- Client pose body with `Physical+Head+Right+Left` valid and `virtualCount=0`: `46 bytes` (matches `test_client_body_size_with_full_pose_no_virtuals`).
+- Room per-client entry (`clientNo + poseTime + clientBody`): `56 bytes`.
 
 | Option | Absolute Position Encoding | Per-axis Range | Client Body Delta | Room Per-client Delta |
 |---|---|---:|---:|---:|
-| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`49 -> 49`) | `+0B` (`59 -> 59`) |
-| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
-| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`49 -> 55`, `+12.2%`) | `+6B` (`59 -> 65`, `+10.2%`) |
+| A. Coarser scale (current integer width) | `int24 @ 0.02m` | `[-167,772.16m, 167,772.14m]` | `+0B` (`46 -> 46`) | `+0B` (`56 -> 56`) |
+| B. Cell + local | `cell(i16, 256m) + local(int24 @ 0.01m)` | `[-8,472,494.08m, 8,472,238.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
+| C. Cell + local (large cell) | `cell(i16, 1024m) + local(int24 @ 0.01m)` | `[-33,638,318.08m, 33,637,294.07m]` | `+6B` (`46 -> 52`, `+13.0%`) | `+6B` (`56 -> 62`, `+10.7%`) |
 
 Notes:
-- Option B/C deltas assume both absolute transforms are present (`physicalPos` and `headPosAbs`).
+- Only `headPosAbs` is on the wire as an absolute field; `physicalPos` is reconstructed from `headPosAbs + xrOriginDelta`. Option B/C deltas therefore apply to `headPosAbs` only.
 - Option B/C can reduce average overhead if `cell` is transmitted only when changed, but that requires extra state and flags in the wire format.
 
 ## Configuration
@@ -121,7 +125,7 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 
 ```json
 {
-  "vars": {
+  "variables": {
     "name": "Jack",
     "lang": "EN"
   }
@@ -140,11 +144,35 @@ The server launches an embedded FastAPI application that exposes REST endpoints
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"name":"Jack","lang":"EN"}}'
+  -d '{"variables":{"name":"Jack","lang":"EN"}}'
 ```
 
 The response includes the current mapping status (`clientNo` or `null`) and whether each key was `"applied"` or `"queued"`.
 
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables` — returns all client variables for the device.
+
+    ```json
+    {"clientNo": 7, "variables": {"name": "Jack", "lang": "EN"}}
+    ```
+
+    If the device has no `clientNo` mapping yet, returns `{"clientNo": null, "variables": {}}`.
+
+  - `GET /v1/rooms/{roomId}/devices/{deviceId}/client-variables/{name}` — returns a single variable.
+
+    ```json
+    {"clientNo": 7, "value": "Jack"}
+    ```
+
+    Returns `404` if the device is unmapped or the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/devices/00000000-0000-0000-0000-000000000000/client-variables/name"
+  ```
+
 ### Global variables
 
 - Endpoint: `POST /v1/rooms/{roomId}/global-variables`
@@ -152,7 +180,7 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 
 ```json
 {
-  "vars": {
+  "variables": {
     "score": "42",
     "stage": "lobby"
   }
@@ -171,7 +199,33 @@ The response includes the current mapping status (`clientNo` or `null`) and whet
 ```bash
 curl -sS -X POST "http://127.0.0.1:8800/v1/rooms/default_room/global-variables" \
   -H "Content-Type: application/json" \
-  -d '{"vars":{"score":"42","stage":"lobby"}}'
+  -d '{"variables":{"score":"42","stage":"lobby"}}'
 ```
 
 The response includes the room ID and whether each key was `"applied"`, `"queued"`, or `"failed"`.
+
+- Read endpoints:
+  - `GET /v1/rooms/{roomId}/global-variables` — returns all global variables for the room.
+
+    ```json
+    {"variables": {"score": "42", "stage": "lobby"}}
+    ```
+
+  - `GET /v1/rooms/{roomId}/global-variables/{name}` — returns a single variable.
+
+    ```json
+    {"value": "42"}
+    ```
+
+    Returns `404` if the variable is not set.
+
+- Example:
+
+  ```bash
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables"
+  curl -sS "http://127.0.0.1:8800/v1/rooms/default_room/global-variables/score"
+  ```
+
+### Read consistency
+
+GET endpoints return a snapshot of the REST bridge's in-process cache, which is populated by PUB-SUB broadcasts from the server. The first request to a room lazily creates a bridge and may return an empty snapshot until the initial broadcasts arrive — retry after a short delay if needed.

{styly_netsync_server-0.10.4 → styly_netsync_server-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.10.4"
+version = "0.12.0"
 description = "STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences"
 readme = "README.md"
 requires-python = ">=3.11"

{styly_netsync_server-0.10.4 → styly_netsync_server-0.12.0}/src/styly_netsync/binary_serializer.py

@@ -6,7 +6,7 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 3
+PROTOCOL_VERSION = 5
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -32,7 +32,7 @@ MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request reject
 _max_virtual_transforms = 50
 MAX_VIRTUAL_TRANSFORMS = _max_virtual_transforms  # Legacy alias for backward compat
 
-# Protocol v3 transform encoding constants
+# Protocol v5 transform encoding constants
 ABS_POS_SCALE = 0.01
 LOCO_POS_SCALE = 0.01
 REL_POS_SCALE = 0.005
@@ -69,6 +69,15 @@ POSE_FLAG_HEAD_VALID = 1 << 2
 POSE_FLAG_RIGHT_VALID = 1 << 3
 POSE_FLAG_LEFT_VALID = 1 << 4
 POSE_FLAG_VIRTUALS_VALID = 1 << 5
+POSE_FLAG_MOVING_FLOOR_LOCAL = 1 << 6
+
+
+def _compute_encoding_flags(flags: int) -> int:
+    """Return pose encoding flags for the sanitized pose flags."""
+    encoding_flags = ENCODING_FLAGS_DEFAULT
+    if flags & POSE_FLAG_MOVING_FLOOR_LOCAL:
+        encoding_flags &= ~ENCODING_PHYSICAL_IS_XRORIGIN_DELTA
+    return encoding_flags & 0xFF
 
 
 def get_max_virtual_transforms() -> int:
@@ -372,7 +381,7 @@ def _create_transform_dict(
 
 
 def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
-    """Serialize a client body in protocol v3 compact format."""
+    """Serialize a client body in protocol v5 compact format."""
     pose_seq = int(client.get("poseSeq", 0)) & 0xFFFF
     head = client.get("head", {}) or {}
     right = client.get("rightHand", {}) or {}
@@ -380,6 +389,7 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
     virtuals = client.get("virtuals", []) or []
     has_xr_origin_delta = (
         "xrOriginDeltaX" in client
+        or "xrOriginDeltaY" in client
         or "xrOriginDeltaZ" in client
         or "xrOriginDeltaYaw" in client
     )
@@ -410,32 +420,51 @@ def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
             POSE_FLAG_RIGHT_VALID | POSE_FLAG_LEFT_VALID | POSE_FLAG_VIRTUALS_VALID
         )
 
+    encoding_flags = _compute_encoding_flags(flags)
     buffer.extend(struct.pack("<H", pose_seq))
     buffer.append(flags)
-    buffer.append(ENCODING_FLAGS_DEFAULT)
+    buffer.append(encoding_flags)
 
     physical_valid = bool(flags & POSE_FLAG_PHYSICAL_VALID)
     head_valid = bool(flags & POSE_FLAG_HEAD_VALID)
     right_valid = head_valid and bool(flags & POSE_FLAG_RIGHT_VALID)
     left_valid = head_valid and bool(flags & POSE_FLAG_LEFT_VALID)
     virtual_valid = head_valid and bool(flags & POSE_FLAG_VIRTUALS_VALID)
+    moving_floor_local = bool(flags & POSE_FLAG_MOVING_FLOOR_LOCAL)
 
     xr_origin_delta_x = float(client.get("xrOriginDeltaX", 0.0))
+    xr_origin_delta_y = float(client.get("xrOriginDeltaY", 0.0))
     xr_origin_delta_z = float(client.get("xrOriginDeltaZ", 0.0))
     xr_origin_delta_yaw = float(client.get("xrOriginDeltaYaw", 0.0))
+    physical = client.get("physical", {}) or {}
     head_pos = _transform_get_position(head)
     head_rot = _transform_get_quaternion(head)
     head_rot_n = _normalize_quaternion(*head_rot)
 
     if physical_valid:
-        buffer.extend(
-            struct.pack(
-                "<hhh",
-                _quantize_signed(xr_origin_delta_x, LOCO_POS_SCALE),
-                _quantize_signed(xr_origin_delta_z, LOCO_POS_SCALE),
-                _quantize_signed(xr_origin_delta_yaw, PHYSICAL_YAW_SCALE),
+        if moving_floor_local:
+            physical_pos = _transform_get_position(physical)
+            physical_rot = _transform_get_quaternion(physical)
+            physical_yaw = _quaternion_to_yaw_degrees(*physical_rot)
+            buffer.extend(
+                struct.pack(
+                    "<hhhh",
+                    _quantize_signed(physical_pos[0], LOCO_POS_SCALE),
+                    _quantize_signed(physical_pos[1], LOCO_POS_SCALE),
+                    _quantize_signed(physical_pos[2], LOCO_POS_SCALE),
+                    _quantize_signed(physical_yaw, PHYSICAL_YAW_SCALE),
+                )
+            )
+        else:
+            buffer.extend(
+                struct.pack(
+                    "<hhhh",
+                    _quantize_signed(xr_origin_delta_x, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_y, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_z, LOCO_POS_SCALE),
+                    _quantize_signed(xr_origin_delta_yaw, PHYSICAL_YAW_SCALE),
+                )
             )
-        )
 
     if head_valid:
         _pack_int24_le(buffer, _quantize_signed_int24(head_pos[0], ABS_POS_SCALE))
@@ -849,7 +878,7 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
 
 
 def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any], int]:
-    """Deserialize protocol v3 compact pose body."""
+    """Deserialize protocol v5 compact pose body."""
     result: dict[str, Any] = {}
     result["poseSeq"] = struct.unpack("<H", data[offset : offset + 2])[0]
     offset += 2
@@ -865,28 +894,41 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     right_valid = head_valid and bool(flags & POSE_FLAG_RIGHT_VALID)
     left_valid = head_valid and bool(flags & POSE_FLAG_LEFT_VALID)
     virtual_valid = head_valid and bool(flags & POSE_FLAG_VIRTUALS_VALID)
+    moving_floor_local = bool(flags & POSE_FLAG_MOVING_FLOOR_LOCAL)
 
     physical = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, True)
-    head = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
-    right = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
-    left = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, False)
+    head = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
+    right = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
+    left = _create_transform_dict(
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
+    )
 
     head_pos = (0.0, 0.0, 0.0)
     head_rot = (0.0, 0.0, 0.0, 1.0)
     xr_origin_delta_x = 0.0
+    xr_origin_delta_y = 0.0
     xr_origin_delta_z = 0.0
     xr_origin_delta_yaw = 0.0
 
     if physical_valid:
-        if (encoding_flags & ENCODING_PHYSICAL_IS_XRORIGIN_DELTA) == 0:
+        if (
+            not moving_floor_local
+            and (encoding_flags & ENCODING_PHYSICAL_IS_XRORIGIN_DELTA) == 0
+        ):
             raise ValueError(
                 "PhysicalValid set but XROrigin delta encoding flag is missing"
             )
-        dx_q, dz_q, dyaw_q = struct.unpack("<hhh", data[offset : offset + 6])
-        xr_origin_delta_x = _dequantize_signed(dx_q, LOCO_POS_SCALE)
-        xr_origin_delta_z = _dequantize_signed(dz_q, LOCO_POS_SCALE)
-        xr_origin_delta_yaw = _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
-        offset += 6
+        dx_q, dy_q, dz_q, dyaw_q = struct.unpack("<hhhh", data[offset : offset + 8])
+        if not moving_floor_local:
+            xr_origin_delta_x = _dequantize_signed(dx_q, LOCO_POS_SCALE)
+            xr_origin_delta_y = _dequantize_signed(dy_q, LOCO_POS_SCALE)
+            xr_origin_delta_z = _dequantize_signed(dz_q, LOCO_POS_SCALE)
+            xr_origin_delta_yaw = _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
+        offset += 8
 
     if head_valid:
         hx_q, offset = _unpack_int24_le(data, offset)
@@ -908,12 +950,31 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             head_rot[1],
             head_rot[2],
             head_rot[3],
-            False,
+            moving_floor_local,
         )
 
-    if physical_valid and head_valid:
+    if physical_valid and moving_floor_local:
+        physical_pos = (
+            _dequantize_signed(dx_q, LOCO_POS_SCALE),
+            _dequantize_signed(dy_q, LOCO_POS_SCALE),
+            _dequantize_signed(dz_q, LOCO_POS_SCALE),
+        )
+        physical_rot = _yaw_degrees_to_quaternion(
+            _dequantize_signed(dyaw_q, PHYSICAL_YAW_SCALE)
+        )
+        physical = _create_transform_dict(
+            physical_pos[0],
+            physical_pos[1],
+            physical_pos[2],
+            physical_rot[0],
+            physical_rot[1],
+            physical_rot[2],
+            physical_rot[3],
+            True,
+        )
+    elif physical_valid and head_valid:
         translated_x = head_pos[0] - xr_origin_delta_x
-        translated_y = head_pos[1]
+        translated_y = head_pos[1] - xr_origin_delta_y
         translated_z = head_pos[2] - xr_origin_delta_z
         physical_pos = _rotate_yaw_vector(
             translated_x,
@@ -965,7 +1026,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             abs_rot[1],
             abs_rot[2],
             abs_rot[3],
-            False,
+            moving_floor_local,
         )
 
     if left_valid:
@@ -994,7 +1055,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
             abs_rot[1],
             abs_rot[2],
             abs_rot[3],
-            False,
+            moving_floor_local,
         )
 
     virtual_count = data[offset]
@@ -1036,11 +1097,12 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
                     abs_rot[1],
                     abs_rot[2],
                     abs_rot[3],
-                    False,
+                    moving_floor_local,
                 )
             )
 
     result["xrOriginDeltaX"] = xr_origin_delta_x
+    result["xrOriginDeltaY"] = xr_origin_delta_y
     result["xrOriginDeltaZ"] = xr_origin_delta_z
     result["xrOriginDeltaYaw"] = xr_origin_delta_yaw
     result["physical"] = physical
@@ -1052,7 +1114,7 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
 
 
 def _deserialize_client_transform(data: bytes, offset: int) -> dict[str, Any]:
-    """Deserialize client pose (v3) from binary data."""
+    """Deserialize client pose (v5) from binary data."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1090,7 +1152,7 @@ def _deserialize_rpc_message(data: bytes, offset: int) -> dict[str, Any]:
 
 
 def _deserialize_room_transform(data: bytes, offset: int) -> dict[str, Any]:
-    """Deserialize room pose (v3) with client numbers only."""
+    """Deserialize room pose (v5) with client numbers only."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]