Implement picking up on game side

rust/src/game_manager.rs

@@ -1211,6 +1211,21 @@ impl Game {
     pub fn recorder(&mut self) -> &mut Option<Gd<ReplayRecorder>> {
         &mut self.replay_recorder
     }
+
+    pub fn on_pickup(&mut self, id: u8, player_id: u16) {
+        self.run_deferred(move |s| {
+            if let Some(map) = &mut s.current_map
+                && let Some(pickup) = map.bind_mut().pickups.get_mut(&id)
+            {
+                pickup.dyn_bind_mut().on_pickup();
+            }
+            if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
+                && let PeerKind::Server(peer, _) = peer
+            {
+                peer.broadcast_reliable(Package::Pickup(id, player_id));
+            }
+        });
+    }
 }
 
 #[derive(Clone, Debug)]

rust/src/net/network_manager.rs

@@ -315,6 +315,7 @@ pub enum Package {
     SwapWeapon(u16, WeaponType),
     Goal(Vec<u8>),
     Announcement(u16, Announcement),
+    Pickup(u8, u16),
 
     // End-of-Game packages
     FinishGame,

rust/src/net/protocol.rs

@@ -226,6 +226,11 @@ impl NetworkManager {
                                 game.bind_mut().on_chat_message(source_id, message);
                             }
                         }
+                        Package::Pickup(pickup_id, player_id) => {
+                            if let Some(game) = &mut Game::singleton() {
+                                game.bind_mut().on_pickup(pickup_id, player_id);
+                            }
+                        }
                         _ => {}
                     },
                 },

rust/src/pickup.rs

@@ -22,6 +22,7 @@ pub struct HealthPickup {
 
     time_elapsed: f64,
     pickup_id: Option<u8>,
+    respawn: f64,
 
     base: Base<Node3D>,
 }
@@ -49,7 +50,11 @@ impl INode3D for HealthPickup {
 
     fn process(&mut self, delta: f64) {
         self.time_elapsed += delta;
+        self.respawn -= delta;
         self.update_common(self.time_elapsed);
+        if let Some(area) = &mut self.pickup_area {
+            area.set_visible(self.respawn <= 0.);
+        }
     }
 }
 
@@ -73,11 +78,21 @@ impl Pickup for HealthPickup {
     fn kind(&self) -> PickupKind {
         PickupKind::Health
     }
+
+    fn id(&self) -> Option<u8> {
+        self.pickup_id
+    }
+
+    fn on_pickup(&mut self) {
+        self.respawn = 10.;
+    }
 }
 
 pub trait Pickup {
     fn area(&mut self) -> &mut Option<Gd<Area3D>>;
     fn kind(&self) -> PickupKind;
+    fn id(&self) -> Option<u8>;
+    fn on_pickup(&mut self);
 }
 
 pub trait PickupCommon {
@@ -97,5 +112,13 @@ impl<T: Pickup> PickupCommon for T {
         if !NetworkManager::singleton().bind().is_host() {
             return;
         }
+        if let Some(game) = &mut Game::singleton()
+            && let Ok(player) = collider.try_dynify::<dyn IPlayer>()
+        {
+            game.bind_mut().on_pickup(
+                self.id().unwrap_or(0),
+                player.dyn_bind().get_player_id().unwrap_or(0),
+            );
+        }
     }
 }