finished initial networking impl

Signed-off-by: Sienna Meridian Satterwhite <sienna@r3t.io>

crates/lib/src/networking/operation_builder.rs

@@ -0,0 +1,251 @@
+//! Build CRDT operations from ECS component changes
+//!
+//! This module provides utilities to convert Bevy component changes into
+//! ComponentOp operations that can be synchronized across the network.
+
+use bevy::{
+    prelude::*,
+    reflect::TypeRegistry,
+};
+
+use crate::{
+    networking::{
+        blob_support::{
+            create_component_data,
+            BlobStore,
+        },
+        error::Result,
+        messages::ComponentData,
+        operations::{
+            ComponentOp,
+            ComponentOpBuilder,
+        },
+        vector_clock::{
+            NodeId,
+            VectorClock,
+        },
+    },
+    persistence::reflection::serialize_component,
+};
+
+/// Build a Set operation (LWW) from a component
+///
+/// Serializes the component using Bevy's reflection system and creates a
+/// ComponentOp::Set for Last-Write-Wins synchronization. Automatically uses
+/// blob storage for components >64KB.
+///
+/// # Parameters
+///
+/// - `component`: The component to serialize
+/// - `component_type`: Type path string
+/// - `node_id`: Our node ID
+/// - `vector_clock`: Current vector clock
+/// - `type_registry`: Bevy's type registry
+/// - `blob_store`: Optional blob store for large components
+///
+/// # Returns
+///
+/// A ComponentOp::Set ready to be broadcast
+pub fn build_set_operation(
+    component: &dyn Reflect,
+    component_type: String,
+    node_id: NodeId,
+    vector_clock: VectorClock,
+    type_registry: &TypeRegistry,
+    blob_store: Option<&BlobStore>,
+) -> Result<ComponentOp> {
+    // Serialize the component
+    let serialized = serialize_component(component, type_registry)?;
+
+    // Create component data (inline or blob)
+    let data = if let Some(store) = blob_store {
+        create_component_data(serialized, store)?
+    } else {
+        ComponentData::Inline(serialized)
+    };
+
+    // Build the operation
+    let builder = ComponentOpBuilder::new(node_id, vector_clock);
+    Ok(builder.set(component_type, data))
+}
+
+/// Build Set operations for all components on an entity
+///
+/// This iterates over all components with reflection data and creates Set
+/// operations for each one. Automatically uses blob storage for large components.
+///
+/// # Parameters
+///
+/// - `entity`: The entity to serialize
+/// - `world`: Bevy world
+/// - `node_id`: Our node ID
+/// - `vector_clock`: Current vector clock
+/// - `type_registry`: Bevy's type registry
+/// - `blob_store`: Optional blob store for large components
+///
+/// # Returns
+///
+/// Vector of ComponentOp::Set operations, one per component
+pub fn build_entity_operations(
+    entity: Entity,
+    world: &World,
+    node_id: NodeId,
+    vector_clock: VectorClock,
+    type_registry: &TypeRegistry,
+    blob_store: Option<&BlobStore>,
+) -> Vec<ComponentOp> {
+    let mut operations = Vec::new();
+    let entity_ref = world.entity(entity);
+
+    // Iterate over all type registrations
+    for registration in type_registry.iter() {
+        // Skip if no ReflectComponent data
+        let Some(reflect_component) = registration.data::<ReflectComponent>() else {
+            continue;
+        };
+
+        // Get the type path
+        let type_path = registration.type_info().type_path();
+
+        // Skip certain components
+        if type_path.ends_with("::NetworkedEntity")
+            || type_path.ends_with("::NetworkedTransform")
+            || type_path.ends_with("::NetworkedSelection")
+            || type_path.ends_with("::NetworkedDrawingPath")
+        {
+            continue;
+        }
+
+        // Try to reflect this component from the entity
+        if let Some(reflected) = reflect_component.reflect(entity_ref) {
+            // Serialize the component
+            if let Ok(serialized) = serialize_component(reflected, type_registry) {
+                // Create component data (inline or blob)
+                let data = if let Some(store) = blob_store {
+                    if let Ok(component_data) = create_component_data(serialized, store) {
+                        component_data
+                    } else {
+                        continue; // Skip this component if blob storage fails
+                    }
+                } else {
+                    ComponentData::Inline(serialized)
+                };
+
+                // Build the operation
+                let mut clock = vector_clock.clone();
+                clock.increment(node_id);
+
+                operations.push(ComponentOp::Set {
+                    component_type: type_path.to_string(),
+                    data,
+                    vector_clock: clock,
+                });
+            }
+        }
+    }
+
+    operations
+}
+
+/// Build a Set operation for Transform component specifically
+///
+/// This is a helper for the common case of synchronizing Transform changes.
+///
+/// # Example
+///
+/// ```
+/// use bevy::prelude::*;
+/// use lib::networking::{build_transform_operation, VectorClock};
+/// use uuid::Uuid;
+///
+/// # fn example(transform: &Transform, type_registry: &bevy::reflect::TypeRegistry) {
+/// let node_id = Uuid::new_v4();
+/// let clock = VectorClock::new();
+///
+/// let op = build_transform_operation(transform, node_id, clock, type_registry, None).unwrap();
+/// # }
+/// ```
+pub fn build_transform_operation(
+    transform: &Transform,
+    node_id: NodeId,
+    vector_clock: VectorClock,
+    type_registry: &TypeRegistry,
+    blob_store: Option<&BlobStore>,
+) -> Result<ComponentOp> {
+    // Use reflection to serialize Transform
+    let serialized = serialize_component(transform.as_reflect(), type_registry)?;
+
+    // Create component data (inline or blob)
+    let data = if let Some(store) = blob_store {
+        create_component_data(serialized, store)?
+    } else {
+        ComponentData::Inline(serialized)
+    };
+
+    let builder = ComponentOpBuilder::new(node_id, vector_clock);
+    Ok(builder.set("bevy_transform::components::transform::Transform".to_string(), data))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_transform_operation() {
+        let mut type_registry = TypeRegistry::new();
+        type_registry.register::<Transform>();
+
+        let transform = Transform::default();
+        let node_id = uuid::Uuid::new_v4();
+        let clock = VectorClock::new();
+
+        let op = build_transform_operation(&transform, node_id, clock, &type_registry, None).unwrap();
+
+        assert!(op.is_set());
+        assert_eq!(
+            op.component_type(),
+            Some("bevy_transform::components::transform::Transform")
+        );
+        assert_eq!(op.vector_clock().get(node_id), 1);
+    }
+
+    #[test]
+    fn test_build_entity_operations() {
+        let mut world = World::new();
+        let mut type_registry = TypeRegistry::new();
+
+        // Register Transform
+        type_registry.register::<Transform>();
+
+        // Spawn entity with Transform
+        let entity = world
+            .spawn(Transform::from_xyz(1.0, 2.0, 3.0))
+            .id();
+
+        let node_id = uuid::Uuid::new_v4();
+        let clock = VectorClock::new();
+
+        let ops = build_entity_operations(entity, &world, node_id, clock, &type_registry, None);
+
+        // Should have at least Transform operation
+        assert!(!ops.is_empty());
+        assert!(ops.iter().all(|op| op.is_set()));
+    }
+
+    #[test]
+    fn test_vector_clock_increment() {
+        let mut type_registry = TypeRegistry::new();
+        type_registry.register::<Transform>();
+
+        let transform = Transform::default();
+        let node_id = uuid::Uuid::new_v4();
+        let mut clock = VectorClock::new();
+
+        let op1 = build_transform_operation(&transform, node_id, clock.clone(), &type_registry, None).unwrap();
+        assert_eq!(op1.vector_clock().get(node_id), 1);
+
+        clock.increment(node_id);
+        let op2 = build_transform_operation(&transform, node_id, clock.clone(), &type_registry, None).unwrap();
+        assert_eq!(op2.vector_clock().get(node_id), 2);
+    }
+}