More implemented.

src/main.rs

@@ -1,32 +1,21 @@
+#[macro_use]
+extern crate rocket;
 mod game;
 use game::GameState;
 use game::Player;
+use rocket::fs::{relative, FileServer};
 use rocket::response::status::BadRequest;
 use rocket::State;
+use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
-
-#[macro_use]
-extern crate rocket;
+use uuid::Uuid;
 
 #[get("/")]
-fn index() -> &'static str {
-    "Hello, world!"
-}
-
-#[get("/shuffle/<player_id>")]
-fn shuffle(
-    player_id: &str,
-    game_state_arc: &State<ArcMutexGameState>,
-) -> Result<String, BadRequest<String>> {
-    let game_state_mutex = Arc::clone(&game_state_arc.state);
-    let mut game_state = game_state_mutex.lock().unwrap();
-    let player = match player_id {
-        "a" => Player::A,
-        "b" => Player::B,
-        _ => return Err(BadRequest(format!("Invalid player {}.", player_id))),
-    };
-    game::shuffle(&mut game_state, player);
-    Ok(format!("Deck Shuffled!"))
+fn index(player_uuids: &State<PlayerUuids>) -> String {
+    format!(
+        "a: localhost:8000/{}/\nb: localhost:8000/{}/",
+        player_uuids.a, player_uuids.b
+    )
 }
 
 #[get("/get_events")]
@@ -36,41 +25,93 @@ fn get_events(game_state_arc: &State<ArcMutexGameState>) -> String {
     format!("{}", game::get_events(&game_state))
 }
 
-#[get("/get_state/<player_id>")]
-fn get_state(
-    player_id: &str,
-    game_state_arc: &State<ArcMutexGameState>,
-) -> Result<String, BadRequest<String>> {
-    let game_state_mutex = Arc::clone(&game_state_arc.state);
-    let game_state = game_state_mutex.lock().unwrap();
-    let player = match player_id {
-        "a" => Player::A,
-        "b" => Player::B,
-        _ => return Err(BadRequest(format!("Invalid player {}.", player_id))),
-    };
-    Ok(format!(
-        "{}",
-        game::get_game_one_player(&game_state, player)
-    ))
-}
-
-#[get("/draw/<player_id>/<count>")]
-fn draw(
-    player_id: &str,
-    count: usize,
+#[post("/<uuid>/shuffle")]
+fn shuffle(
+    uuid: Uuid,
     game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
 ) -> Result<String, BadRequest<String>> {
     let game_state_mutex = Arc::clone(&game_state_arc.state);
     let mut game_state = game_state_mutex.lock().unwrap();
-    let player = match player_id {
-        "a" => Player::A,
-        "b" => Player::B,
-        _ => return Err(BadRequest(format!("Invalid player {}.", player_id))),
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    game::shuffle(&mut game_state, player.clone());
+    Ok(format!("Deck Shuffled!"))
+}
+
+#[get("/<uuid>/pass")]
+fn pass(
+    uuid: Uuid,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    match player_uuids.map.get(&uuid) {
+        Some(_) => (),
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    game::pass(&mut game_state);
+    Ok(format!("{}", game::get_events(&game_state)))
+}
+
+#[get("/<uuid>/get_state")]
+fn get_state(
+    uuid: Uuid,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let game_state = game_state_mutex.lock().unwrap();
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    Ok(format!(
+        "{}",
+        game::get_game_one_player(&game_state, player.clone())
+    ))
+}
+
+#[get("/<uuid>/draw/<count>")]
+fn draw(
+    uuid: Uuid,
+    count: usize,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
     };
     game::draw(&mut game_state, count, player.clone());
     Ok(format!(
         "{}",
-        game::get_game_one_player(&game_state, player)
+        game::get_game_one_player(&game_state, player.clone())
+    ))
+}
+
+#[get("/<uuid>/life/<count>")]
+fn life(
+    uuid: Uuid,
+    count: i32,
+    game_state_arc: &State<ArcMutexGameState>,
+    player_uuids: &State<PlayerUuids>,
+) -> Result<String, BadRequest<String>> {
+    let game_state_mutex = Arc::clone(&game_state_arc.state);
+    let mut game_state = game_state_mutex.lock().unwrap();
+    let player = match player_uuids.map.get(&uuid) {
+        Some(player) => player,
+        None => return Err(BadRequest(format!("Invalid player {}.", uuid))),
+    };
+    game::change_life(&mut game_state, count, player.clone());
+    Ok(format!(
+        "{}",
+        game::get_game_one_player(&game_state, player.clone())
     ))
 }
 
@@ -78,16 +119,41 @@ struct ArcMutexGameState {
     state: Arc<Mutex<GameState>>,
 }
 
+struct PlayerUuids {
+    a: Uuid,
+    b: Uuid,
+    map: HashMap<Uuid, Player>,
+}
+
 #[launch]
 fn rocket() -> _ {
-    let mut game_state = game::new();
+    let game_state = game::new();
     let game_state_arc = Arc::new(Mutex::new(game_state));
+    let a_uuid: Uuid = Uuid::new_v4();
+    let b_uuid: Uuid = Uuid::new_v4();
+    let uuid_map = HashMap::from([(a_uuid, Player::A), (b_uuid, Player::B)]);
+    println!("A: {}", a_uuid);
+    println!("B: {}", b_uuid);
+
     rocket::build()
-        .mount("/", routes![index, get_events])
-        .mount("/", routes![get_state])
-        .mount("/", routes![draw])
-        .mount("/", routes![shuffle])
+        .mount(
+            format!("/{}", a_uuid.hyphenated()),
+            FileServer::from(relative!("static")),
+        )
+        .mount(
+            format!("/{}", b_uuid.hyphenated()),
+            FileServer::from(relative!("static")),
+        )
+        .mount(
+            "/",
+            routes![index, get_events, get_state, draw, shuffle, pass, life,],
+        )
         .manage(ArcMutexGameState {
             state: game_state_arc,
         })
+        .manage(PlayerUuids {
+            a: a_uuid,
+            b: b_uuid,
+            map: uuid_map,
+        })
 }