rust/src/game_manager.rs

@@ -1162,7 +1162,9 @@ impl Game {
 
         if let Some(player) = self.find_player_mut(player_id) {
             if let Some(character) = &mut player.character {
-                character.dyn_bind_mut().take_damage(source, damage, false);
+                character
+                    .dyn_bind_mut()
+                    .take_damage(source, damage, false, true);
             }
         }
     }
@@ -1171,7 +1173,7 @@ impl Game {
     pub fn handle_kill(&mut self, source: DamageSource, player_id: u16) {
         if let Some(player) = self.find_player_mut(player_id) {
             if let Some(character) = &mut player.character {
-                character.dyn_bind_mut().kill(source.clone());
+                character.dyn_bind_mut().kill(source.clone(), true);
                 self.on_kill(source, player_id);
             }
         }

rust/src/killbox.rs

@@ -70,9 +70,12 @@ impl Killbox {
     pub fn kill(&mut self, node: Gd<Node3D>) {
         if let Ok(mut player) = node.clone().try_dynify::<dyn IPlayer>() {
             if NetworkManager::singleton().bind().is_host() {
-                player
+                player.dyn_bind_mut().take_damage(
-                    .dyn_bind_mut()
+                    DamageSource::Killbox(self.kind),
-                    .take_damage(DamageSource::Killbox(self.kind), 1000, true);
+                    1000,
+                    true,
+                    true,
+                );
             }
         } else if let Ok(_) = node.try_cast::<Ball>() {
             if let Some(game) = &mut Game::singleton() {

rust/src/map.rs

@@ -117,7 +117,6 @@ impl Map {
             node.bind_mut().player_id = Some(player_id);
             node.bind_mut().player_name = player.name.clone();
             node.bind_mut().player_color = player.color.clone().into();
-            node.bind_mut().replay_mode = true;
             self.base_mut().add_child(&node);
 
             node.bind_mut()
@@ -146,6 +145,7 @@ impl Map {
         {
             let mut ball = ball_prefab.instantiate_as::<Ball>();
             ball.bind_mut().dropper = player_id;
+            ball.bind_mut().active = true;
             self.base_mut().add_child(&ball);
             if let Some(transform) = transform {
                 ball.set_global_position(transform.location.into());
@@ -173,6 +173,7 @@ impl Map {
         {
             let mut ball = ball_prefab.instantiate_as::<Ball>();
             ball.bind_mut().dropper = player_id;
+            ball.bind_mut().active = false;
             self.base_mut().add_child(&ball);
             if let Some(transform) = transform {
                 ball.set_global_position(transform.location.into());

rust/src/player/ball.rs

@@ -12,6 +12,7 @@ use crate::{
 #[class(base=RigidBody3D, init)]
 pub struct Ball {
     pub dropper: Option<u16>,
+    pub active: bool,
 
     alive_for: f64,
 
@@ -49,6 +50,9 @@ impl Ball {
     }
 
     fn on_collision(&mut self, node: Gd<Node>) {
+        if !self.active {
+            return;
+        }
         if let Ok(player) = node.try_dynify::<dyn IPlayer>()
             && let Some(player_id) = player.dyn_bind().get_player_id()
         {

rust/src/player/local_player.rs

@@ -171,7 +171,7 @@ impl IPlayer for LocalPlayer {
     fn apply_look_up(&mut self, _look: f32) {}
 
     fn try_shoot(&mut self, to: Vector3, deal_damage: bool) -> bool {
-        if self.try_shoot_common(to, deal_damage) {
+        if self.try_shoot_common(to, deal_damage, deal_damage) {
             if let Some(game) = &mut Game::singleton()
                 && let Some(recorder) = game.bind_mut().recorder()
             {
@@ -209,7 +209,7 @@ impl IPlayer for LocalPlayer {
         }
     }
 
-    fn take_damage(&mut self, source: DamageSource, damage: i32, kill: bool) {
+    fn take_damage(&mut self, source: DamageSource, damage: i32, kill: bool, drop_ball: bool) {
         self.run_deferred(move |s| {
             if s.can_take_damage(&source) {
                 let (signal, player, kind) = source.into_signal();
@@ -220,7 +220,7 @@ impl IPlayer for LocalPlayer {
                 });
                 s.health -= damage;
                 if kill && s.health <= 0 {
-                    s.kill(source);
+                    s.kill(source, drop_ball);
                 }
             }
             if let Some(health_label) = &mut s.health_label {
@@ -237,8 +237,10 @@ impl IPlayer for LocalPlayer {
         self.dead_for
     }
 
-    fn kill(&mut self, source: DamageSource) {
+    fn kill(&mut self, source: DamageSource, drop_ball: bool) {
+        if drop_ball {
             self.drop_ball(false);
+        }
 
         let (signal, player, kind) = source.into_signal();
         self.run_deferred(move |s| s.signals().on_die().emit(signal, player, kind));
@@ -301,10 +303,6 @@ impl IPlayer for LocalPlayer {
     fn get_camera_origin(&self) -> Option<Gd<Node3D>> {
         self.camera_origin.clone()
     }
-
-    fn is_replay_mode(&self) -> bool {
-        false
-    }
 }
 
 #[godot_api]
@@ -723,6 +721,6 @@ impl LocalPlayer {
 #[godot_dyn]
 impl Shootable for LocalPlayer {
     fn on_shoot(&mut self, source: DamageSource, damage: i32, _: Vector3) {
-        self.take_damage(source, damage, true);
+        self.take_damage(source, damage, true, true);
     }
 }

rust/src/player/mod.rs

@@ -47,16 +47,21 @@ pub trait IPlayer {
     fn jump(&mut self);
     fn try_shoot(&mut self, to: Vector3, deal_damage: bool) -> bool;
     fn try_punch(&mut self, to: Vector3, deal_damage: bool) -> bool;
-    fn take_damage(&mut self, source_player: DamageSource, damage: i32, kill: bool);
+    fn take_damage(
+        &mut self,
+        source_player: DamageSource,
+        damage: i32,
+        kill: bool,
+        drop_ball: bool,
+    );
     fn is_dead(&self) -> bool;
-    fn kill(&mut self, source_player: DamageSource);
+    fn kill(&mut self, source_player: DamageSource, drop_ball: bool);
     fn dead_for(&self) -> f64;
     fn swap_weapon(&mut self, weapon: WeaponType, drop_ball: bool);
     fn get_weapon(&self) -> Option<DynGd<Node3D, dyn Weapon>>;
     fn take_weapon(&mut self) -> Option<DynGd<Node3D, dyn Weapon>>;
     fn drop_ball(&mut self, with_velocity: bool) -> bool;
     fn get_camera_origin(&self) -> Option<Gd<Node3D>>;
-    fn is_replay_mode(&self) -> bool;
 }
 
 pub trait PlayerCommon {
@@ -65,7 +70,7 @@ pub trait PlayerCommon {
     fn drop_ball_common(&mut self, with_velocity: bool) -> bool;
     fn get_look_dir(&self) -> Vector3;
     fn can_take_damage(&self, source: &DamageSource) -> bool;
-    fn try_shoot_common(&mut self, to: Vector3, deal_damage: bool) -> bool;
+    fn try_shoot_common(&mut self, to: Vector3, deal_damage: bool, drop_ball: bool) -> bool;
     fn try_punch_common(&mut self, to: Vector3, deal_damage: bool) -> bool;
 }
 
@@ -177,12 +182,12 @@ impl<T: IPlayer + ICharacterBody3D + WithBaseField> PlayerCommon for T {
         true
     }
 
-    fn try_shoot_common(&mut self, to: Vector3, deal_damage: bool) -> bool {
+    fn try_shoot_common(&mut self, to: Vector3, deal_damage: bool, drop_ball: bool) -> bool {
         if self.is_dead() {
             return false;
         }
 
-        if !self.is_replay_mode() && self.drop_ball(true) {
+        if drop_ball && self.drop_ball(true) {
             return true;
         }
 

rust/src/player/remote_player.rs

@@ -48,7 +48,6 @@ pub struct RemotePlayer {
     pub player_id: Option<u16>,
     pub player_name: String,
     pub player_color: Color,
-    pub replay_mode: bool,
 
     movement_dir: Vector3,
     y_speed: f32,
@@ -127,7 +126,7 @@ impl IPlayer for RemotePlayer {
     }
 
     fn try_shoot(&mut self, to: Vector3, deal_damage: bool) -> bool {
-        self.try_shoot_common(to, deal_damage)
+        self.try_shoot_common(to, deal_damage, deal_damage)
     }
 
     fn try_punch(&mut self, to: Vector3, deal_damage: bool) -> bool {
@@ -139,7 +138,7 @@ impl IPlayer for RemotePlayer {
         }
     }
 
-    fn take_damage(&mut self, source: DamageSource, damage: i32, kill: bool) {
+    fn take_damage(&mut self, source: DamageSource, damage: i32, kill: bool, drop_ball: bool) {
         self.run_deferred(move |s| {
             if s.can_take_damage(&source) {
                 let (signal, player, kind) = source.into_signal();
@@ -150,7 +149,7 @@ impl IPlayer for RemotePlayer {
                 });
                 s.health -= damage;
                 if kill && s.health <= 0 {
-                    s.kill(source);
+                    s.kill(source, drop_ball);
                 }
             }
             if let Some(health_bar) = &mut s.health_bar {
@@ -168,8 +167,8 @@ impl IPlayer for RemotePlayer {
         self.dead_for
     }
 
-    fn kill(&mut self, source: DamageSource) {
+    fn kill(&mut self, source: DamageSource, drop_ball: bool) {
-        if !self.replay_mode {
+        if drop_ball {
             self.drop_ball(false);
         }
 
@@ -226,10 +225,6 @@ impl IPlayer for RemotePlayer {
     fn get_camera_origin(&self) -> Option<Gd<Node3D>> {
         self.camera_origin.clone()
     }
-
-    fn is_replay_mode(&self) -> bool {
-        self.replay_mode
-    }
 }
 
 #[godot_api]
@@ -293,6 +288,6 @@ impl RemotePlayer {
 #[godot_dyn]
 impl Shootable for RemotePlayer {
     fn on_shoot(&mut self, source: DamageSource, damage: i32, _: Vector3) {
-        self.take_damage(source, damage, true);
+        self.take_damage(source, damage, true, true);
     }
 }

rust/src/replay.rs

@@ -197,7 +197,7 @@ impl INode for ReplayPlayback {
                     match event {
                         ReplayEvent::Death(damage_source, player_id) => {
                             if let Some(character) = self.player_characters.get_mut(player_id) {
-                                character.bind_mut().kill(*damage_source);
+                                character.bind_mut().kill(*damage_source, false);
                             }
                         }
                         ReplayEvent::Shoot(player_id, to) => {
@@ -234,9 +234,12 @@ impl INode for ReplayPlayback {
                         }
                         ReplayEvent::TakeDamage(player_id, damage_source, damage) => {
                             if let Some(character) = self.player_characters.get_mut(player_id) {
-                                character
+                                character.bind_mut().take_damage(
-                                    .bind_mut()
+                                    *damage_source,
-                                    .take_damage(*damage_source, *damage, false);
+                                    *damage,
+                                    false,
+                                    false,
+                                );
                             }
                         }
                     }