Put player name and color into ReplayPlayer

rust/src/game_manager.rs

@@ -822,7 +822,7 @@ impl Game {
             let team = self.find_player(id).map(|p| p.data.team).unwrap_or(0);
             let mut character =
                 map.bind_mut()
-                    .spawn_player(id, team, id == self.self_id.unwrap_or(0), None);
+                    .spawn_player(id, team, id == self.self_id.unwrap_or(0), None, true);
 
             if let Some(character) = &mut character {
                 if let Some(player) = self.find_player(id) {
@@ -904,6 +904,7 @@ impl Game {
                     player.data.team,
                     player.id() == self.self_id.unwrap_or(0),
                     Some(transform),
+                    true,
                 );
                 if let Some(character) = &mut character {
                     character

rust/src/map.rs

@@ -6,7 +6,7 @@ use crate::{
     player::{
         IPlayer, NetTransform, ball::Ball, local_player::LocalPlayer, remote_player::RemotePlayer,
     },
-    replay::ReplayPlayerState,
+    replay::{ReplayPlayer, ReplayPlayerState},
 };
 
 #[derive(GodotClass)]
@@ -50,6 +50,7 @@ impl Map {
         team: u8,
         is_local: bool,
         transform: Option<NetTransform>,
+        get_remote_data: bool,
     ) -> Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>> {
         if is_local {
             if let Some(local_player) = &self.local_player {
@@ -77,6 +78,19 @@ impl Map {
         } else if let Some(remote_player) = &self.remote_player {
             let mut node = remote_player.instantiate_as::<RemotePlayer>();
             node.bind_mut().player_id = Some(player_id);
+            if get_remote_data {
+                let mut node_clone = node.clone();
+                self.run_deferred(move |_| {
+                    if let Some(game) = &mut Game::singleton()
+                        && let Some(player) = game.bind().find_player(player_id)
+                        && let Some(team) = game.bind().get_team(player.data.team)
+                    {
+                        node_clone.bind_mut().player_name = player.data.name.clone();
+                        node_clone.bind_mut().player_color = team.bind().color.clone();
+                    }
+                });
+            }
+
             self.base_mut().add_child(&node);
             if let Some(transform) = transform {
                 node.bind_mut()
@@ -101,11 +115,14 @@ impl Map {
     pub fn spawn_replay_player(
         &mut self,
         player_id: u16,
+        player: &ReplayPlayer,
         state: ReplayPlayerState,
     ) -> Option<Gd<RemotePlayer>> {
         if let Some(replay_player) = &self.replay_player {
             let mut node: Gd<RemotePlayer> = replay_player.instantiate_as();
             node.bind_mut().player_id = Some(player_id);
+            node.bind_mut().player_name = player.name.clone();
+            node.bind_mut().player_color = player.color;
             self.base_mut().add_child(&node);
 
             node.bind_mut()

rust/src/player/remote_player.rs

@@ -46,6 +46,8 @@ pub struct RemotePlayer {
     health_bar_sprite: Option<Gd<Sprite3D>>,
 
     pub player_id: Option<u16>,
+    pub player_name: String,
+    pub player_color: Color,
 
     movement_dir: Vector3,
     y_speed: f32,
@@ -227,14 +229,9 @@ impl IPlayer for RemotePlayer {
 impl ICharacterBody3D for RemotePlayer {
     fn ready(&mut self) {
         self.run_deferred(|s| {
-            if let Some(player_id) = s.player_id
+            if let Some(name_label) = &mut s.name_label {
-                && let Some(game) = Game::singleton()
+                name_label.set_text(&s.player_name);
-                && let Some(player) = game.bind().find_player(player_id)
+                name_label.set_modulate(s.player_color);
-                && let Some(team) = game.bind().get_team(player.data.team)
-                && let Some(name_label) = &mut s.name_label
-            {
-                name_label.set_text(&player.data.name);
-                name_label.set_modulate(team.bind().color);
             }
         });
 

rust/src/replay.rs

@@ -74,9 +74,13 @@ impl INode for ReplayPlayback {
             if !self.fast_forwarding {
                 if let Some(map) = &mut self.current_map {
                     for (id, data) in &frame.player_data {
-                        if !self.player_characters.contains_key(id) && !data.is_dead {
+                        if !self.player_characters.contains_key(id)
+                            && !data.is_dead
+                            && let Some(player) = self.replay.players.get(id)
+                        {
                             if let Some(player) =
-                                map.bind_mut().spawn_replay_player(*id, data.clone())
+                                map.bind_mut()
+                                    .spawn_replay_player(*id, player, data.clone())
                             {
                                 self.player_characters.insert(*id, player);
                             }
@@ -101,10 +105,14 @@ impl INode for ReplayPlayback {
                                 character.queue_free();
                             }
 
-                            if let Some(map) = &mut self.current_map {
+                            if let Some(map) = &mut self.current_map
-                                if let Some(player) =
+                                && let Some(player) = self.replay.players.get(player_id)
-                                    map.bind_mut().spawn_replay_player(*player_id, data.clone())
                             {
+                                if let Some(player) = map.bind_mut().spawn_replay_player(
+                                    *player_id,
+                                    player,
+                                    data.clone(),
+                                ) {
                                     self.player_characters.insert(*player_id, player);
                                 }
                             }
@@ -196,15 +204,18 @@ impl INode for ReplayRecorder {
 
             if let Some(game) = &Game::singleton() {
                 for player in &game.bind().players {
+                    if let Some(team) = game.bind().get_team(player.data.team) {
                         s.replay.players.insert(
                             player.id(),
                             ReplayPlayer {
                                 id: player.id(),
                                 name: player.data.name.clone(),
+                                color: team.bind().color,
                             },
                         );
                     }
                 }
+            }
         });
     }
 
@@ -270,8 +281,9 @@ impl Default for Replay {
 
 #[derive(Debug, Clone)]
 pub struct ReplayPlayer {
-    id: u16,
+    pub id: u16,
-    name: String,
+    pub name: String,
+    pub color: Color,
 }
 
 #[derive(Debug, Default, Clone)]