replaytools sends end packet, quit movie mode on replay end

1 files changed, 35 insertions, 27 deletions

diff --git a/server/replaytool/src/main.rs b/server/replaytool/src/main.rs
index 331c6e6d..337152ec 100644
--- a/server/replaytool/src/main.rs
+++ b/server/replaytool/src/main.rs
@@ -120,7 +120,13 @@ async fn main() -> anyhow::Result<()> {
                     serde_json::to_string(&PacketC::ReplayStart).unwrap().into(),
                 ))
                 .await?;
-                'outer: while let Some(Ok(message)) = sock.next().await {
+                while let Some(Ok(message)) = sock.next().await {
+                    let mut send = async |p: PacketC| {
+                        sock.send(tokio_tungstenite::tungstenite::Message::Text(
+                            serde_json::to_string(&p).unwrap().into(),
+                        ))
+                        .await
+                    };
                     match message {
                         tungstenite::Message::Text(line) => {
                             let packet: PacketS = match serde_json::from_str(&line) {
@@ -134,28 +140,19 @@ async fn main() -> anyhow::Result<()> {
 
                             match packet {
                                 PacketS::Join { .. } => {
-                                    sock.send(tokio_tungstenite::tungstenite::Message::Text(
-                                        serde_json::to_string(&PacketC::ServerMessage {
-                                            message: Message::Translation {
-                                                id: "s.replay.cannot_join".to_owned(),
-                                                params: vec![],
-                                            },
-                                            error: true,
-                                        })
-                                        .unwrap()
-                                        .into(),
-                                    ))
+                                    send(PacketC::ServerMessage {
+                                        message: Message::Translation {
+                                            id: "s.replay.cannot_join".to_owned(),
+                                            params: vec![],
+                                        },
+                                        error: true,
+                                    })
                                     .await?;
                                 }
                                 PacketS::Idle { paused: pause } => {
                                     // Cannot display server hint like in main server because cant address them to spectators.
                                     paused = pause;
-                                    sock.send(tokio_tungstenite::tungstenite::Message::Text(
-                                        serde_json::to_string(&PacketC::Pause { state: pause })
-                                            .unwrap()
-                                            .into(),
-                                    ))
-                                    .await?
+                                    send(PacketC::Pause { state: pause }).await?
                                 }
                                 PacketS::ReplayTick { dt } => {
                                     if paused {
@@ -164,18 +161,29 @@ async fn main() -> anyhow::Result<()> {
                                     time += dt;
                                     while next_event.ts < time {
                                         debug!("<- {:?}", next_event.packet);
-                                        sock.send(tokio_tungstenite::tungstenite::Message::Text(
-                                            serde_json::to_string(&next_event.packet)
-                                                .unwrap()
-                                                .into(),
-                                        ))
-                                        .await?;
+                                        if !matches!(
+                                            next_event.packet,
+                                            PacketC::SetIngame { state: false, .. }
+                                        ) {
+                                            send(next_event.packet).await?;
+                                        }
 
-                                        let Some(next) = &file.next_line().await? else {
+                                        if let Some(next) = &file.next_line().await? {
+                                            next_event = serde_json::from_str::<Event>(next)?;
+                                        } else {
                                             info!("reached end");
-                                            break 'outer;
+                                            send(PacketC::ServerMessage {
+                                                message: Message::Text("End of Replay".to_string()),
+                                                error: false,
+                                            })
+                                            .await?;
+                                            send(PacketC::ReplayStop).await?;
+                                            next_event = Event {
+                                                ts: f64::INFINITY,
+                                                packet: PacketC::FlushMap,
+                                            };
+                                            continue;
                                         };
-                                        next_event = serde_json::from_str::<Event>(next)?;
                                     }
                                 }
                                 x => warn!("unhandled client packet: {x:?}"),