Network updates enabled

orthros-client/src/main.rs

@@ -21,9 +21,25 @@ fn main() {
     App::new()
         .add_plugins((DefaultPlugins, WireframePlugin::default()))
         .add_systems(Startup, (setup_scene, start_socket))
-        .add_systems(Update, (receive_messages, update_stars))
+        .add_systems(Update, (receive_messages, update_stars, keep_alive))
         .run();
 }
+fn keep_alive(mut commands: Commands, mut socket: ResMut<MatchboxSocket>) {
+    match socket.try_update_peers() {
+        Ok(peers) => {
+            for (peer, state) in peers {
+                info!("{peer}: {state:?}");
+            }
+        }
+        Err(e) => {
+            error!("{e:?}");
+            commands.remove_resource::<MatchboxSocket>();
+            let socket = MatchboxSocket::new_reliable("ws://localhost:3536/hello");
+            info!("Connection established");
+            commands.insert_resource(socket);
+        }
+    }
+}
 fn create_star_system_annotation(
     commands: &mut Commands,
     asset_server: &Res<AssetServer>,
@@ -245,18 +261,25 @@ fn start_socket(mut commands: Commands) {
 fn update_stars(
     mut commands: Commands,
     network_stars: Query<(Entity, &StarInfo)>,
-    spawned_stars: Query<(Entity, &EntityID)>,
+    mut spawned_stars: Query<(Entity, &EntityID, &mut Transform)>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     asset_server: Res<AssetServer>,
     mut images: ResMut<Assets<Image>>,
 ) {
     for (id, network_star) in network_stars {
-        if let Some((entity, _)) = spawned_stars
+        if let Some((entity, _, transform)) = spawned_stars
-            .iter()
+            .iter_mut()
-            .filter(|(_, spawned_id)| **spawned_id == network_star.id)
+            .filter(|(_, spawned_id, _)| **spawned_id == network_star.id)
             .last()
+            .as_mut()
         {
+            commands
+                .get_entity(*entity)
+                .unwrap()
+                .insert(network_star.transform);
+            // *transform = network_star.transform;
+
             // let entity_command = commands.get_entity(entity).unwrap();
         } else {
             spawn_star(
@@ -272,18 +295,15 @@ fn update_stars(
     }
 }
 fn receive_messages(mut socket: ResMut<MatchboxSocket>, mut commands: Commands) {
-    for (peer, state) in socket.update_peers() {
-        info!("{peer}: {state:?}");
-    }
-
     for (_id, message) in socket.channel_mut(CHANNEL_ID).receive() {
         match NetworkObject::deserialize(&mut Deserializer::new(&*message)) {
             Ok(message) => {
-                info!("Received message: {message:?}");
+                // info!("Received message: {message:?}");
                 match message {
                     NetworkObject::Star(star_info) => {
                         commands.spawn(star_info);
                     }
+                    NetworkObject::Planet() => todo!(),
                 }
             }
             Err(e) => error!("Failed to convert message to string: {e}"),

orthros-network/src/generic/mod.rs

@@ -6,4 +6,5 @@ pub struct EntityID(pub u32);
 #[derive(Serialize, Deserialize, Debug, Component)]
 pub enum NetworkObject {
     Star(StarInfo),
+    Planet(),
 }

orthros-server/src/main.rs

@@ -1,7 +1,7 @@
 pub mod temporal_management;
 use bevy::{
     prelude::*,
-    render::{RenderPlugin, settings::WgpuSettings, view::Hdr},
+    render::{RenderPlugin, settings::WgpuSettings},
     time::common_conditions::on_timer,
 };
 use bevy_matchbox::{matchbox_signaling::SignalingServer, prelude::*};
@@ -14,8 +14,8 @@ use rand::{
     distr::{Distribution, Uniform},
     rng,
 };
-use rmp_serde::{Deserializer, Serializer};
+use rmp_serde::Serializer;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::{
     collections::HashSet,
     net::{Ipv4Addr, SocketAddrV4},
@@ -25,6 +25,8 @@ use std::{
 const CHANNEL_ID: usize = 0;
 #[derive(Component)]
 struct Changed;
+#[derive(Component)]
+struct Star;
 fn main() {
     App::new()
         .add_plugins((DefaultPlugins.set(RenderPlugin {
@@ -45,7 +47,10 @@ fn main() {
         )
         .add_systems(
             Update,
-            (send_message.run_if(on_timer(Duration::from_secs(5))),),
+            (
+                move_stars,
+                send_message.run_if(on_timer(Duration::from_millis(100))),
+            ),
         )
         .run();
 }
@@ -95,16 +100,7 @@ fn setup_scene(mut commands: Commands, mut socket: ResMut<MatchboxSocket>) {
             transform: Transform::from_xyz(x as f32 / 100.0, z as f32 / 20000.0, z as f32 / 100.0),
         };
 
-        commands.spawn((NetworkObject::Star(star_info), Changed));
+        commands.spawn((NetworkObject::Star(star_info), Changed, Star));
-        let peers: Vec<_> = socket.connected_peers().collect();
-
-        for peer in peers {
-            let message = "Hello";
-            info!("Sending message: {message:?} to {peer}");
-            socket
-                .channel_mut(CHANNEL_ID)
-                .send(message.as_bytes().into(), peer);
-        }
     }
 }
 fn start_socket(mut commands: Commands) {
@@ -115,7 +111,7 @@ fn start_socket(mut commands: Commands) {
 
 fn send_message(mut socket: ResMut<MatchboxSocket>, network_objects: Query<&NetworkObject>) {
     for (peer, state) in socket.update_peers() {
-        info!("{peer}: {state:?}");
+        // info!("{peer}: {state:?}");
     }
 
     let peers: Vec<_> = socket.connected_peers().collect();
@@ -124,10 +120,24 @@ fn send_message(mut socket: ResMut<MatchboxSocket>, network_objects: Query<&Netw
         for network_object in network_objects.iter() {
             let mut ser_buf: Vec<u8> = Vec::new();
             network_object.serialize(&mut Serializer::new(&mut ser_buf));
-            info!("Sending message: {ser_buf:?} to {peer}");
+            // info!("Sending message: {ser_buf:?} to {peer}");
             socket
                 .channel_mut(CHANNEL_ID)
                 .send(ser_buf.as_slice().into(), peer);
         }
     }
 }
+fn move_stars(mut network_objects: Query<&mut NetworkObject, With<Star>>, time: Res<Time>) {
+    for mut no in network_objects.iter_mut() {
+        if let NetworkObject::Star(star) = no.as_mut() {
+            star.transform.rotate_around(
+                Vec3 {
+                    x: 0.0,
+                    y: 0.0,
+                    z: 0.0,
+                },
+                Quat::from_rotation_y(time.delta_secs() * 0.05),
+            )
+        }
+    }
+}