Implement ball_sync

rust/src/ball.rs

@@ -4,7 +4,7 @@ use godot::{
 };
 
 use crate::{
-    net::util::NetVector3,
+    net::{network_manager::BallSync, util::NetVector3},
     player::{IPlayer, NetTransform},
 };
 
@@ -61,4 +61,22 @@ impl Ball {
             self.run_deferred(move |s| s.signals().on_ball_pickup().emit(player_id));
         }
     }
+
+    pub fn get_sync(&self) -> BallSync {
+        BallSync {
+            transform: NetTransform {
+                location: self.base().get_global_position().into(),
+                rotation: self.base().get_global_rotation().into(),
+            },
+            velocity: self.base().get_linear_velocity().into(),
+        }
+    }
+
+    pub fn apply_sync(&mut self, sync: BallSync) {
+        self.base_mut()
+            .set_global_position(sync.transform.location.into());
+        self.base_mut()
+            .set_global_rotation(sync.transform.rotation.into());
+        self.base_mut().set_linear_velocity(sync.velocity.into());
+    }
 }

rust/src/game_manager.rs

@@ -9,7 +9,7 @@ use crate::{
     map_resource::MapResource,
     net::{
         network_manager::{
-            NetworkManager,
+            BallSync, NetworkManager,
             Package::{self, Kill, SelfSync, SpawnPlayer, TakeDamage},
             PeerKind, SyncPackage,
         },
@@ -147,7 +147,10 @@ impl INode for Game {
                                     );
                                 }
                             }
-                            peer.broadcast_unreliable(Package::Sync(sync_data));
+                            peer.broadcast_unreliable(Package::Sync(
+                                sync_data,
+                                self.world_ball.as_ref().map(|b| b.bind().get_sync()),
+                            ));
                         }
                     }
                 }
@@ -458,7 +461,11 @@ impl Game {
     }
 
     // Handle a sync package from the server
-    pub fn handle_sync(&mut self, sync_data: HashMap<u16, SyncPackage>) {
+    pub fn handle_sync(
+        &mut self,
+        sync_data: HashMap<u16, SyncPackage>,
+        ball_sync: Option<BallSync>,
+    ) {
         for (
             player_id,
             SyncPackage {
@@ -486,6 +493,12 @@ impl Game {
                 }
             }
         }
+
+        if let Some(ball_sync) = ball_sync
+            && let Some(ball) = &mut self.world_ball
+        {
+            ball.bind_mut().apply_sync(ball_sync);
+        }
     }
 
     // Handle a jump, either from the server or from a client

rust/src/net/network_manager.rs

@@ -218,9 +218,9 @@ impl INode for NetworkManager {
                                             game.bind_mut().spawn_player_client(id, transform);
                                         }
                                     }
-                                    Package::Sync(sync_data) => {
+                                    Package::Sync(sync_data, ball_sync) => {
                                         if let Some(game) = &mut Game::singleton() {
-                                            game.bind_mut().handle_sync(sync_data);
+                                            game.bind_mut().handle_sync(sync_data, ball_sync);
                                         }
                                     }
                                     Package::Jump(player_id) => {
@@ -592,7 +592,7 @@ pub enum Package {
 
     // Game packages
     SpawnPlayer(u16, NetTransform),
-    Sync(HashMap<u16, SyncPackage>),
+    Sync(HashMap<u16, SyncPackage>, Option<BallSync>),
     SelfSync(SyncPackage),
     Jump(u16),
     Shoot(u16, NetVector3, NetTransform, f32),
@@ -610,6 +610,12 @@ pub struct SyncPackage {
     pub transform: NetTransform,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BallSync {
+    pub transform: NetTransform,
+    pub velocity: NetVector3,
+}
+
 pub enum PeerKind {
     Client(Peer<Package>, SocketAddr),
     Server(Peer<Package>, u16),