styly-netsync-server 0.11.0__tar.gz → 0.13.0__tar.gz

{styly_netsync_server-0.11.0 → styly_netsync_server-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.11.0
+Version: 0.13.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,14 +81,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 4`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V4 pose body.
-- v4 vs. v3: `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 (e.g. elevators).
+- 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 v4 position quantization ranges:
+- 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 (`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.
+  - 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.
 
@@ -96,7 +98,7 @@ 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=4`):
+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`.
 

{styly_netsync_server-0.11.0 → styly_netsync_server-0.13.0}/README.md

@@ -42,14 +42,16 @@ styly-netsync-simulator --server tcp://localhost --room my_room --clients 50
 
 ## Wire protocol compatibility
 
-- Current transform wire protocol is `protocolVersion = 4`.
-- Transform messages use `MSG_CLIENT_POSE` (11) and `MSG_ROOM_POSE` (12) with the compact V4 pose body.
-- v4 vs. v3: `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 (e.g. elevators).
+- 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 v4 position quantization ranges:
+- 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 (`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.
+  - 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.
 
@@ -57,7 +59,7 @@ 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=4`):
+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`.
 

{styly_netsync_server-0.11.0 → styly_netsync_server-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.11.0"
+version = "0.13.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.11.0 → styly_netsync_server-0.13.0}/src/styly_netsync/binary_serializer.py

@@ -6,7 +6,7 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 4
+PROTOCOL_VERSION = 5
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -24,6 +24,7 @@ MSG_ROOM_OBJECTS = 14  # Server → Clients (PUB): room object states
 MSG_OBJECT_OWNERSHIP_REQUEST = 15  # Client → Server: RequestOwnership/ReleaseOwnership
 MSG_OBJECT_OWNERSHIP_CHANGED = 16  # Server → Clients (ROUTER): ownership changed
 MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request rejected
+MSG_CLIENT_VAR_CLEAR = 18  # Clear all client variables for the sender
 
 # Transform data type identifiers (deprecated - kept for reference)
 
@@ -32,7 +33,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 v4 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 +70,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 +382,7 @@ def _create_transform_dict(
 
 
 def _serialize_client_body(buffer: bytearray, client: dict[str, Any]) -> None:
-    """Serialize a client body in protocol v4 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 {}
@@ -411,34 +421,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(
-                "<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 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))
@@ -739,6 +766,26 @@ def serialize_client_var_set(data: dict[str, Any]) -> bytes:
     return bytes(buffer)
 
 
+def serialize_client_var_clear(data: dict[str, Any]) -> bytes:
+    """Serialize client variable clear message.
+
+    Args:
+        data: Dictionary with senderClientNo and timestamp.
+    """
+    buffer = bytearray()
+
+    # Message type
+    buffer.append(MSG_CLIENT_VAR_CLEAR)
+
+    # Sender client number (2 bytes)
+    buffer.extend(struct.pack("<H", data.get("senderClientNo", 0)))
+
+    # Timestamp (8 bytes double)
+    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
+
+    return bytes(buffer)
+
+
 def serialize_client_var_sync(data: dict[str, Any]) -> bytes:
     """Serialize client variable sync message
 
@@ -785,10 +832,7 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
     offset += 1
 
     # Validate message type is within valid range
-    if (
-        message_type < MSG_CLIENT_TRANSFORM
-        or message_type > MSG_OBJECT_OWNERSHIP_REJECTED
-    ):
+    if message_type < MSG_CLIENT_TRANSFORM or message_type > MSG_CLIENT_VAR_CLEAR:
         # Return invalid message type with None data instead of raising exception
         return message_type, None, b""
 
@@ -817,6 +861,8 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
             return message_type, _deserialize_client_var_set(data, offset), b""
         elif message_type == MSG_CLIENT_VAR_SYNC:
             return message_type, _deserialize_client_var_sync(data, offset), b""
+        elif message_type == MSG_CLIENT_VAR_CLEAR:
+            return message_type, _deserialize_client_var_clear(data, offset), b""
         elif message_type == MSG_OBJECT_POSE:
             return message_type, _deserialize_object_pose(data, offset), b""
         elif message_type == MSG_ROOM_OBJECTS:
@@ -852,7 +898,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 v4 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
@@ -868,11 +914,14 @@ 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)
@@ -882,15 +931,19 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     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, dy_q, dz_q, dyaw_q = struct.unpack("<hhhh", data[offset : offset + 8])
-        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)
+        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:
@@ -913,10 +966,29 @@ 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] - xr_origin_delta_y
         translated_z = head_pos[2] - xr_origin_delta_z
@@ -970,7 +1042,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:
@@ -999,7 +1071,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]
@@ -1041,7 +1113,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,
                 )
             )
 
@@ -1058,7 +1130,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 (v4) from binary data."""
+    """Deserialize client pose (v5) from binary data."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1096,7 +1168,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 (v4) with client numbers only."""
+    """Deserialize room pose (v5) with client numbers only."""
     result: dict[str, Any] = {}
 
     protocol_version = data[offset]
@@ -1229,6 +1301,20 @@ def _deserialize_client_var_set(data: bytes, offset: int) -> dict[str, Any]:
     return result
 
 
+def _deserialize_client_var_clear(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize client variable clear message."""
+    result: dict[str, Any] = {}
+
+    # Sender client number (2 bytes)
+    result["senderClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
+    offset += 2
+
+    # Timestamp (8 bytes double)
+    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
+
+    return result
+
+
 def _deserialize_client_var_sync(data: bytes, offset: int) -> dict[str, Any]:
     """Deserialize client variable sync message"""
     result: dict[str, Any] = {"clientVariables": {}}

{styly_netsync_server-0.11.0 → styly_netsync_server-0.13.0}/src/styly_netsync/client.py

@@ -1027,7 +1027,11 @@ class net_sync_manager:
             logger.error(f"Error processing global var sync: {e}")
 
     def _process_client_var_sync(self, msg_data: dict[str, Any]) -> None:
-        """Process client variable sync."""
+        """Process client variable sync.
+
+        Each included client number is a full authoritative snapshot. Missing
+        keys are removed from the local cache for that client.
+        """
         try:
             client_variables = msg_data.get("clientVariables", {})
 
@@ -1037,34 +1041,50 @@ class net_sync_manager:
                 except ValueError:
                     continue
 
-                if client_no not in self._client_variables:
-                    self._client_variables[client_no] = {}
+                old_vars = self._client_variables.get(client_no, {})
+                new_vars: dict[str, str] = {}
 
                 for var in variables:
                     name = var.get("name", "")
                     value = var.get("value", "")
-                    old_value = self._client_variables[client_no].get(name)
+                    if name:
+                        new_vars[name] = value
 
-                    self._client_variables[client_no][name] = value
+                changed_events: list[tuple[int, str, str | None, str | None]] = []
+                for name in set(old_vars) - set(new_vars):
+                    changed_events.append((client_no, name, old_vars.get(name), None))
 
+                for name, value in new_vars.items():
+                    old_value = old_vars.get(name)
                     if old_value != value:
-                        with self._lock:
-                            self._stats["nv_updates"] += 1
+                        changed_events.append((client_no, name, old_value, value))
 
-                        event = ("client", client_no, name, old_value, value)
-                        if self._auto_dispatch:
-                            self.on_client_variable_changed.invoke(
-                                client_no, name, old_value, value
-                            )
-                        else:
+                self._client_variables[client_no] = new_vars
+
+                for event_client_no, name, old_value, new_value in changed_events:
+                    with self._lock:
+                        self._stats["nv_updates"] += 1
+
+                    event: tuple[str, int, str, str | None, str | None] = (
+                        "client",
+                        event_client_no,
+                        name,
+                        old_value,
+                        new_value,
+                    )
+                    if self._auto_dispatch:
+                        self.on_client_variable_changed.invoke(
+                            event_client_no, name, old_value, new_value
+                        )
+                    else:
+                        try:
+                            self._nv_queue.put_nowait(event)
+                        except Full:
                             try:
+                                self._nv_queue.get_nowait()
                                 self._nv_queue.put_nowait(event)
-                            except Full:
-                                try:
-                                    self._nv_queue.get_nowait()
-                                    self._nv_queue.put_nowait(event)
-                                except Empty:
-                                    pass
+                            except Empty:
+                                pass
 
         except Exception as e:
             logger.error(f"Error processing client var sync: {e}")
@@ -1235,6 +1255,28 @@ class net_sync_manager:
             logger.error(f"Error queueing client variable: {e}")
             return False
 
+    def clear_my_client_variables(self) -> bool:
+        """Queue a request to clear this client's variables on the server."""
+        if not self._running or not self._dealer_socket or self._client_no is None:
+            return False
+
+        try:
+            clear_data = {
+                "senderClientNo": self._client_no,
+                "timestamp": time.time(),
+            }
+            message = binary_serializer.serialize_client_var_clear(clear_data)
+            sent = self._enqueue_control(
+                self._room, message, msg_type="client_variable_clear"
+            )
+            if sent:
+                self._clear_local_client_variables(self._client_no)
+            return sent
+
+        except Exception as e:
+            logger.error(f"Error queueing client variable clear: {e}")
+            return False
+
     def _enqueue_control(
         self, room_id: str, payload: bytes, msg_type: str = "control"
     ) -> bool:
@@ -1294,6 +1336,34 @@ class net_sync_manager:
         """Return a copy of all variables for the given client."""
         return self._client_variables.get(client_no, {}).copy()
 
+    def _clear_local_client_variables(self, client_no: int) -> None:
+        """Clear local client-variable cache for a client and emit events."""
+        old_vars = self._client_variables.get(client_no, {}).copy()
+        self._client_variables[client_no] = {}
+
+        for name, old_value in old_vars.items():
+            with self._lock:
+                self._stats["nv_updates"] += 1
+
+            event: tuple[str, int, str, str | None, str | None] = (
+                "client",
+                client_no,
+                name,
+                old_value,
+                None,
+            )
+            if self._auto_dispatch:
+                self.on_client_variable_changed.invoke(client_no, name, old_value, None)
+            else:
+                try:
+                    self._nv_queue.put_nowait(event)
+                except Full:
+                    try:
+                        self._nv_queue.get_nowait()
+                        self._nv_queue.put_nowait(event)
+                    except Empty:
+                        pass
+
     def is_client_stealth_mode(self, client_no: int) -> bool:
         """Check if the client is in stealth mode."""
         return self._client_stealth_flags.get(client_no, False)

{styly_netsync_server-0.11.0 → styly_netsync_server-0.13.0}/src/styly_netsync/client_simulator.py

@@ -46,6 +46,7 @@ import zmq
 # Import public APIs from styly_netsync module
 from styly_netsync.binary_serializer import (
     MSG_CLIENT_POSE,
+    MSG_CLIENT_VAR_CLEAR,
     MSG_CLIENT_VAR_SET,
     MSG_CLIENT_VAR_SYNC,
     MSG_DEVICE_ID_MAPPING,
@@ -95,6 +96,7 @@ MESSAGE_TYPE_NAMES: dict[int, str] = {
     MSG_GLOBAL_VAR_SYNC: "GLOBAL_VAR_SYNC",
     MSG_CLIENT_VAR_SET: "CLIENT_VAR_SET",
     MSG_CLIENT_VAR_SYNC: "CLIENT_VAR_SYNC",
+    MSG_CLIENT_VAR_CLEAR: "CLIENT_VAR_CLEAR",
     MSG_OBJECT_POSE: "OBJECT_POSE",
     MSG_ROOM_OBJECTS: "ROOM_OBJECTS",
     MSG_OBJECT_OWNERSHIP_REQUEST: "OBJECT_OWNERSHIP_REQUEST",