Sync jumps

rust/src/game_manager.rs

@@ -308,6 +308,14 @@ impl Game {
             }
         }
     }
+
+    pub fn handle_jump(&mut self, player_id: u16) {
+        if player_id != self.self_id.unwrap_or(0) {
+            if let Some(player) = self.find_player_mut(player_id) {
+                player.apply_jump();
+            }
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -366,6 +374,12 @@ impl Player {
             character.dyn_bind_mut().apply_rotation(rot.into());
         }
     }
+
+    pub fn apply_jump(&mut self) {
+        if let Some(character) = &mut self.character {
+            character.dyn_bind_mut().jump();
+        }
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]

rust/src/net/network_manager.rs

@@ -222,6 +222,11 @@ impl INode for NetworkManager {
                                             game.bind_mut().handle_sync(sync_data);
                                         }
                                     }
+                                    Package::Jump(player_id) => {
+                                        if let Some(game) = &mut Game::singleton() {
+                                            game.bind_mut().handle_jump(player_id);
+                                        }
+                                    }
                                     _ => {}
                                 },
                             }
@@ -361,6 +366,18 @@ impl INode for NetworkManager {
                                             }
                                         }
                                     }
+                                    Package::Jump(_) => {
+                                        if let Some(game) = &mut Game::singleton() {
+                                            let player = game
+                                                .bind()
+                                                .find_player_by_addr(&conn.address)
+                                                .cloned();
+                                            if let Some(player) = player {
+                                                game.bind_mut().handle_jump(player.id);
+                                                peer.broadcast_reliable(Package::Jump(player.id));
+                                            }
+                                        }
+                                    }
                                     _ => {}
                                 },
                             }
@@ -471,19 +488,26 @@ impl NetworkManager {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Package {
     Hello,
+
+    // Meta values
     Players(Vec<NetPlayer>, u16),
+    UpdatePings(HashMap<u16, u128>),
     SetNick(u16, String),
     SetSelfNick(String),
-    UpdatePings(HashMap<u16, u128>),
     NewPlayer(NetPlayer),
     PlayerLeft(NetPlayer),
+
+    // Lobby packages
     SetReady(u16, bool),
     SelectMap(u8),
     GameStarted,
+    MapLoaded,
+
+    // Game packages
     SpawnPlayer(u16, NetPlayerTransform),
     Sync(HashMap<u16, (NetVector3, NetPlayerTransform)>),
     SelfSync(NetVector3, NetVector3),
-    MapLoaded,
+    Jump(u16),
 }
 
 pub enum PeerKind {

rust/src/player.rs

@@ -10,7 +10,13 @@ use godot::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::{net::util::NetVector3, ui::cli::CommandLinePanel};
+use crate::{
+    net::{
+        network_manager::{NetworkManager, Package::Jump, PeerKind},
+        util::NetVector3,
+    },
+    ui::cli::CommandLinePanel,
+};
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize)]
 pub struct NetPlayerTransform {
@@ -28,11 +34,11 @@ pub trait IPlayer {
     fn apply_transform(&mut self, transform: NetPlayerTransform);
     fn apply_rotation(&mut self, rot: Vector3);
     fn get_transform(&self) -> NetPlayerTransform;
+    fn jump(&mut self);
 }
 
 pub trait PlayerMovement {
     fn player_update(&mut self, delta: f64);
-    fn jump(&mut self);
 }
 
 impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerMovement for T {
@@ -53,10 +59,6 @@ impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerMovement for T {
         self.base_mut().set_velocity(speed);
         self.base_mut().move_and_slide();
     }
-
-    fn jump(&mut self) {
-        self.set_y_speed(5.);
-    }
 }
 
 #[derive(GodotClass)]
@@ -118,6 +120,18 @@ impl IPlayer for LocalPlayer {
             rotation: self.base().get_global_rotation().into(),
         }
     }
+
+    fn jump(&mut self) {
+        self.set_y_speed(5.);
+        if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
+            match peer {
+                PeerKind::Client(peer, addr) => peer.send_reliable(&addr, Jump(0)),
+                PeerKind::Server(peer, _) => {
+                    peer.broadcast_reliable(Jump(self.player_id.unwrap_or(0)))
+                }
+            }
+        }
+    }
 }
 
 #[godot_api]
@@ -247,6 +261,10 @@ impl IPlayer for RemotePlayer {
             rotation: self.base().get_global_rotation().into(),
         }
     }
+
+    fn jump(&mut self) {
+        self.set_y_speed(5.);
+    }
 }
 
 #[godot_api]