map download tool

1 files changed, 71 insertions, 3 deletions

diff --git a/server/replaytool/src/main.rs b/server/replaytool/src/main.rs
index 7ef70087..7f60287f 100644
--- a/server/replaytool/src/main.rs
+++ b/server/replaytool/src/main.rs
@@ -26,15 +26,18 @@ use crate::{
     render::{RenderArgs, render},
     replay::replay,
 };
+use anyhow::Context;
 use clap::Parser;
-use hurrycurry_protocol::PacketC;
-use log::{LevelFilter, info, warn};
+use futures_util::{SinkExt, StreamExt};
+use hurrycurry_protocol::{Character, Message, PacketC, PacketS, PlayerClass};
+use log::{LevelFilter, debug, error, info, warn};
 use serde::{Deserialize, Serialize};
 use std::{
     path::PathBuf,
     time::{Duration, SystemTime},
 };
 use tokio::{net::TcpListener, time::sleep};
+use tokio_tungstenite::tungstenite::{self};
 
 #[derive(Parser)]
 enum Args {
@@ -47,9 +50,15 @@ enum Args {
         output: PathBuf,
     },
     /// Starts a local server that replays previously recorded sessions
-    Replay { input: PathBuf },
+    Replay {
+        input: PathBuf,
+    },
     /// Runs a replay server and the client in movie mode to record that replay
     Render(#[command(flatten)] RenderArgs),
+    DownloadMap {
+        url: String,
+        mapname: String,
+    },
 }
 
 #[derive(Serialize, Deserialize)]
@@ -109,6 +118,65 @@ async fn main() -> anyhow::Result<()> {
         Args::Render(a) => {
             render(a).await?;
         }
+        Args::DownloadMap { url, mapname } => {
+            download_map(&url, &mapname).await?;
+        }
+    }
+    Ok(())
+}
+
+pub async fn download_map(url: &str, mapname: &str) -> anyhow::Result<()> {
+    let (mut sock, _) = tokio_tungstenite::connect_async(url).await?;
+
+    sock.send(tungstenite::Message::Text(
+        serde_json::to_string(&PacketS::Join {
+            name: "map downloader".to_string(),
+            character: Character::default(),
+            class: PlayerClass::Chef,
+            id: None,
+            position: None,
+        })
+        .unwrap()
+        .into(),
+    ))
+    .await?;
+
+    while let Some(Ok(message)) = sock.next().await {
+        match message {
+            tungstenite::Message::Text(line) => {
+                let packet: PacketC = serde_json::from_str(&line).context("invalid packet")?;
+                debug!("<- {packet:?}");
+
+                match packet {
+                    PacketC::Joined { id } => {
+                        sock.send(tungstenite::Message::Text(
+                            serde_json::to_string(&PacketC::Communicate {
+                                player: id,
+                                message: Some(Message::Text(format!("/download map {mapname}"))),
+                                timeout: None,
+                            })
+                            .unwrap()
+                            .into(),
+                        ))
+                        .await?;
+                    }
+                    PacketC::ServerMessage {
+                        message: Message::Text(t),
+                        ..
+                    } => {
+                        println!("{t}");
+                        return Ok(());
+                    }
+                    _ => (),
+                }
+            }
+            tungstenite::Message::Close(_) => {
+                error!("connection closed by server");
+                break;
+            }
+            _ => (),
+        }
     }
+
     Ok(())
 }