From 9b522f0789e7c983a90d238aba36740695688f3c Mon Sep 17 00:00:00 2001
From: Sofia <sofia@teascade.net>
Date: Sun, 26 Jul 2026 19:30:12 +0300
Subject: [PATCH] Record deaths and shoots

---
 rust/src/game_manager.rs | 14 +++++++++++++-
 rust/src/replay.rs       | 41 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 51 insertions(+), 4 deletions(-)

diff --git a/rust/src/game_manager.rs b/rust/src/game_manager.rs
index 4916c84..39c6e9a 100644
--- a/rust/src/game_manager.rs
+++ b/rust/src/game_manager.rs
@@ -23,7 +23,7 @@ use crate::{
         DamageSource, IPlayer, NetTransform, ball::Ball, local_player::LocalPlayer,
         remote_player::RemotePlayer, weapon::WeaponType,
     },
-    replay::{ReplayPlayback, ReplayRecorder},
+    replay::{ReplayEvent, ReplayPlayback, ReplayRecorder},
     team_resource::TeamResource,
     ui::cli::{Command, CommandLinePanel},
 };
@@ -920,6 +920,12 @@ impl Game {
         look_up: f32,
         deal_damage: bool,
     ) -> bool {
+        if let Some(recorder) = &mut self.replay_recorder {
+            recorder
+                .bind_mut()
+                .record_event(ReplayEvent::Shoot(player_id, to));
+        }
+
         let self_id = self.self_id.clone().unwrap_or(0);
         if let Some(player) = self.find_player_mut(player_id) {
             if player.id() != self_id {
@@ -955,6 +961,12 @@ impl Game {
 
     // Handle for when a player is killed, run both on client and server
     pub fn on_kill(&mut self, source: DamageSource, player_id: u16) {
+        if let Some(recorder) = &mut self.replay_recorder {
+            recorder
+                .bind_mut()
+                .record_event(ReplayEvent::Death(source, player_id));
+        }
+
         if let DamageSource::Player(source_player_id) = source
             && let Some(player) = self.find_player(source_player_id)
             && let Some(character) = player.character.clone()
diff --git a/rust/src/replay.rs b/rust/src/replay.rs
index ac9e8f4..debd8fa 100644
--- a/rust/src/replay.rs
+++ b/rust/src/replay.rs
@@ -6,7 +6,9 @@ use crate::{
     game_manager::{Game, Player},
     map::Map,
     net::util::NetVector3,
-    player::{IPlayer, NetTransform, remote_player::RemotePlayer, weapon::WeaponType},
+    player::{
+        DamageSource, IPlayer, NetTransform, remote_player::RemotePlayer, weapon::WeaponType,
+    },
 };
 
 #[derive(GodotClass)]
@@ -43,6 +45,21 @@ impl INode for ReplayPlayback {
                 }
             }
 
+            for event in &frame.events {
+                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);
+                        }
+                    }
+                    ReplayEvent::Shoot(player_id, to) => {
+                        if let Some(character) = self.player_characters.get_mut(player_id) {
+                            character.bind_mut().try_shoot(*to, false);
+                        }
+                    }
+                }
+            }
+
             for (id, mut character) in self.player_characters.clone() {
                 if let Some(state) = frame.player_data.get(&id) {
                     character.bind_mut().apply_transform(state.transform);
@@ -76,6 +93,18 @@ impl INode for ReplayRecorder {
     fn ready(&mut self) {
         self.run_deferred(|s| {
             s.current_frame = s.record_frame();
+
+            if let Some(game) = &Game::singleton() {
+                for player in &game.bind().players {
+                    s.replay.players.insert(
+                        player.id(),
+                        ReplayPlayer {
+                            id: player.id(),
+                            name: player.data.name.clone(),
+                        },
+                    );
+                }
+            }
         });
     }
 
@@ -90,6 +119,10 @@ impl INode for ReplayRecorder {
 }
 
 impl ReplayRecorder {
+    pub fn record_event(&mut self, event: ReplayEvent) {
+        self.current_frame.events.push(event);
+    }
+
     fn record_frame(&mut self) -> ReplayFrame {
         let mut player_data = HashMap::new();
 
@@ -128,7 +161,6 @@ impl Default for Replay {
 pub struct ReplayPlayer {
     id: u16,
     name: String,
-    initial_state: ReplayPlayerState,
 }
 
 #[derive(Debug, Default, Clone)]
@@ -139,7 +171,10 @@ pub struct ReplayFrame {
 }
 
 #[derive(Debug, Clone)]
-pub enum ReplayEvent {}
+pub enum ReplayEvent {
+    Death(DamageSource, u16),
+    Shoot(u16, Vector3),
+}
 
 #[derive(Debug)]
 pub enum ReplayBall {